[go: nahoru, domu]
Google Git
Sign in
chromium / chromium / src / 4b3edfc1840f7038d8c5a7186635b3b03ffda078 / . / net / http / http_cache_unittest.cc
blob: ebe25df196c80b1022da8121e4c1324cf6984378 [file] [log] [blame]
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/http/http_cache.h"
#include <stdint.h>
#include <algorithm>
#include <memory>
#include <set>
#include <utility>
#include <vector>
#include "base/containers/cxx20_erase.h"
#include "base/files/scoped_temp_dir.h"
#include "base/format_macros.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/memory/ptr_util.h"
#include "base/memory/raw_ptr.h"
#include "base/run_loop.h"
#include "base/strings/strcat.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/simple_test_clock.h"
#include "base/time/time.h"
#include "base/trace_event/memory_allocator_dump.h"
#include "base/trace_event/memory_dump_request_args.h"
#include "base/trace_event/process_memory_dump.h"
#include "net/base/cache_type.h"
#include "net/base/completion_repeating_callback.h"
#include "net/base/elements_upload_data_stream.h"
#include "net/base/features.h"
#include "net/base/host_port_pair.h"
#include "net/base/ip_address.h"
#include "net/base/ip_endpoint.h"
#include "net/base/load_flags.h"
#include "net/base/load_timing_info.h"
#include "net/base/load_timing_info_test_util.h"
#include "net/base/net_errors.h"
#include "net/base/schemeful_site.h"
#include "net/base/tracing.h"
#include "net/base/upload_bytes_element_reader.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_byte_range.h"
#include "net/http/http_cache_transaction.h"
#include "net/http/http_request_headers.h"
#include "net/http/http_request_info.h"
#include "net/http/http_response_headers.h"
#include "net/http/http_response_info.h"
#include "net/http/http_transaction.h"
#include "net/http/http_transaction_test_util.h"
#include "net/http/http_util.h"
#include "net/http/mock_http_cache.h"
#include "net/log/net_log_event_type.h"
#include "net/log/net_log_source.h"
#include "net/log/net_log_with_source.h"
#include "net/log/test_net_log.h"
#include "net/log/test_net_log_util.h"
#include "net/socket/client_socket_handle.h"
#include "net/ssl/ssl_cert_request_info.h"
#include "net/ssl/ssl_connection_status_flags.h"
#include "net/test/cert_test_util.h"
#include "net/test/gtest_util.h"
#include "net/test/test_data_directory.h"
#include "net/test/test_with_task_environment.h"
#include "net/websockets/websocket_handshake_stream_base.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/abseil-cpp/absl/types/optional.h"
#include "url/origin.h"
using net::test::IsError;
using net::test::IsOk;
using testing::AllOf;
using testing::ByRef;
using testing::Contains;
using testing::ElementsAre;
using testing::Eq;
using testing::Field;
using testing::Gt;
using testing::IsEmpty;
using testing::NotNull;
using base::Time;
namespace net {
using CacheEntryStatus = HttpResponseInfo::CacheEntryStatus;
class WebSocketEndpointLockManager;
namespace {
// Returns a simple text serialization of the given
// |HttpResponseHeaders|. This is used by tests to verify that an
// |HttpResponseHeaders| matches an expectation string.
//
// * One line per header, written as:
// HEADER_NAME: HEADER_VALUE\n
// * The original case of header names is preserved.
// * Whitespace around head names/values is stripped.
// * Repeated headers are not aggregated.
// * Headers are listed in their original order.
// TODO(tfarina): this is a duplicate function from
// http_response_headers_unittest.cc:ToSimpleString(). Figure out how to merge
// them. crbug.com/488593
std::string ToSimpleString(const scoped_refptr<HttpResponseHeaders>& parsed) {
std::string result = parsed->GetStatusLine() + "\n";
size_t iter = 0;
std::string name;
std::string value;
while (parsed->EnumerateHeaderLines(&iter, &name, &value)) {
std::string new_line = name + ": " + value + "\n";
result += new_line;
}
return result;
}
// Tests the load timing values of a request that goes through a
// MockNetworkTransaction.
void TestLoadTimingNetworkRequest(const LoadTimingInfo& load_timing_info) {
EXPECT_FALSE(load_timing_info.socket_reused);
EXPECT_NE(NetLogSource::kInvalidId, load_timing_info.socket_log_id);
EXPECT_TRUE(load_timing_info.proxy_resolve_start.is_null());
EXPECT_TRUE(load_timing_info.proxy_resolve_end.is_null());
ExpectConnectTimingHasTimes(load_timing_info.connect_timing,
CONNECT_TIMING_HAS_CONNECT_TIMES_ONLY);
EXPECT_LE(load_timing_info.connect_timing.connect_end,
load_timing_info.send_start);
EXPECT_LE(load_timing_info.send_start, load_timing_info.send_end);
// Set by URLRequest / URLRequestHttpJob, at a higher level.
EXPECT_TRUE(load_timing_info.request_start_time.is_null());
EXPECT_TRUE(load_timing_info.request_start.is_null());
EXPECT_TRUE(load_timing_info.receive_headers_end.is_null());
}
// Tests the load timing values of a request that receives a cached response.
void TestLoadTimingCachedResponse(const LoadTimingInfo& load_timing_info) {
EXPECT_FALSE(load_timing_info.socket_reused);
EXPECT_EQ(NetLogSource::kInvalidId, load_timing_info.socket_log_id);
EXPECT_TRUE(load_timing_info.proxy_resolve_start.is_null());
EXPECT_TRUE(load_timing_info.proxy_resolve_end.is_null());
ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
// Only the send start / end times should be sent, and they should have the
// same value.
EXPECT_FALSE(load_timing_info.send_start.is_null());
EXPECT_EQ(load_timing_info.send_start, load_timing_info.send_end);
// Set by URLRequest / URLRequestHttpJob, at a higher level.
EXPECT_TRUE(load_timing_info.request_start_time.is_null());
EXPECT_TRUE(load_timing_info.request_start.is_null());
EXPECT_TRUE(load_timing_info.receive_headers_end.is_null());
}
void DeferCallback(bool* defer) {
*defer = true;
}
class DeleteCacheCompletionCallback : public TestCompletionCallbackBase {
public:
explicit DeleteCacheCompletionCallback(std::unique_ptr<MockHttpCache> cache)
: cache_(std::move(cache)) {}
DeleteCacheCompletionCallback(const DeleteCacheCompletionCallback&) = delete;
DeleteCacheCompletionCallback& operator=(
const DeleteCacheCompletionCallback&) = delete;
CompletionOnceCallback callback() {
return base::BindOnce(&DeleteCacheCompletionCallback::OnComplete,
base::Unretained(this));
}
private:
void OnComplete(int result) {
cache_.reset();
SetResult(result);
}
std::unique_ptr<MockHttpCache> cache_;
};
//-----------------------------------------------------------------------------
// helpers
void ReadAndVerifyTransaction(HttpTransaction* trans,
const MockTransaction& trans_info) {
std::string content;
int rv = ReadTransaction(trans, &content);
EXPECT_THAT(rv, IsOk());
std::string expected(trans_info.data);
EXPECT_EQ(expected, content);
}
void ReadRemainingAndVerifyTransaction(HttpTransaction* trans,
const std::string& already_read,
const MockTransaction& trans_info) {
std::string content;
int rv = ReadTransaction(trans, &content);
EXPECT_THAT(rv, IsOk());
std::string expected(trans_info.data);
EXPECT_EQ(expected, already_read + content);
}
void RunTransactionTestBase(HttpCache* cache,
const MockTransaction& trans_info,
const MockHttpRequest& request,
HttpResponseInfo* response_info,
const NetLogWithSource& net_log,
LoadTimingInfo* load_timing_info,
int64_t* sent_bytes,
int64_t* received_bytes,
IPEndPoint* remote_endpoint) {
TestCompletionCallback callback;
// write to the cache
std::unique_ptr<HttpTransaction> trans;
int rv = cache->CreateTransaction(DEFAULT_PRIORITY, &trans);
EXPECT_THAT(rv, IsOk());
ASSERT_TRUE(trans.get());
rv = trans->Start(&request, callback.callback(), net_log);
if (rv == ERR_IO_PENDING)
rv = callback.WaitForResult();
ASSERT_EQ(trans_info.start_return_code, rv);
if (OK != rv)
return;
const HttpResponseInfo* response = trans->GetResponseInfo();
ASSERT_TRUE(response);
if (response_info)
*response_info = *response;
if (load_timing_info) {
// If a fake network connection is used, need a NetLog to get a fake socket
// ID.
EXPECT_TRUE(net_log.net_log());
*load_timing_info = LoadTimingInfo();
trans->GetLoadTimingInfo(load_timing_info);
}
if (remote_endpoint)
ASSERT_TRUE(trans->GetRemoteEndpoint(remote_endpoint));
ReadAndVerifyTransaction(trans.get(), trans_info);
if (sent_bytes)
*sent_bytes = trans->GetTotalSentBytes();
if (received_bytes)
*received_bytes = trans->GetTotalReceivedBytes();
}
void RunTransactionTestWithRequest(HttpCache* cache,
const MockTransaction& trans_info,
const MockHttpRequest& request,
HttpResponseInfo* response_info) {
RunTransactionTestBase(cache, trans_info, request, response_info,
NetLogWithSource(), nullptr, nullptr, nullptr,
nullptr);
}
void RunTransactionTestAndGetTiming(HttpCache* cache,
const MockTransaction& trans_info,
const NetLogWithSource& log,
LoadTimingInfo* load_timing_info) {
RunTransactionTestBase(cache, trans_info, MockHttpRequest(trans_info),
nullptr, log, load_timing_info, nullptr, nullptr,
nullptr);
}
void RunTransactionTestAndGetTimingAndConnectedSocketAddress(
HttpCache* cache,
const MockTransaction& trans_info,
const NetLogWithSource& log,
LoadTimingInfo* load_timing_info,
IPEndPoint* remote_endpoint) {
RunTransactionTestBase(cache, trans_info, MockHttpRequest(trans_info),
nullptr, log, load_timing_info, nullptr, nullptr,
remote_endpoint);
}
void RunTransactionTest(HttpCache* cache, const MockTransaction& trans_info) {
RunTransactionTestAndGetTiming(cache, trans_info, NetLogWithSource(),
nullptr);
}
void RunTransactionTestWithLog(HttpCache* cache,
const MockTransaction& trans_info,
const NetLogWithSource& log) {
RunTransactionTestAndGetTiming(cache, trans_info, log, nullptr);
}
void RunTransactionTestWithResponseInfo(HttpCache* cache,
const MockTransaction& trans_info,
HttpResponseInfo* response) {
RunTransactionTestWithRequest(cache, trans_info, MockHttpRequest(trans_info),
response);
}
void RunTransactionTestWithResponseInfoAndGetTiming(
HttpCache* cache,
const MockTransaction& trans_info,
HttpResponseInfo* response,
const NetLogWithSource& log,
LoadTimingInfo* load_timing_info) {
RunTransactionTestBase(cache, trans_info, MockHttpRequest(trans_info),
response, log, load_timing_info, nullptr, nullptr,
nullptr);
}
void RunTransactionTestWithResponse(HttpCache* cache,
const MockTransaction& trans_info,
std::string* response_headers) {
HttpResponseInfo response;
RunTransactionTestWithResponseInfo(cache, trans_info, &response);
*response_headers = ToSimpleString(response.headers);
}
void RunTransactionTestWithResponseAndGetTiming(
HttpCache* cache,
const MockTransaction& trans_info,
std::string* response_headers,
const NetLogWithSource& log,
LoadTimingInfo* load_timing_info) {
HttpResponseInfo response;
RunTransactionTestBase(cache, trans_info, MockHttpRequest(trans_info),
&response, log, load_timing_info, nullptr, nullptr,
nullptr);
*response_headers = ToSimpleString(response.headers);
}
// This class provides a handler for kFastNoStoreGET_Transaction so that the
// no-store header can be included on demand.
class FastTransactionServer {
public:
FastTransactionServer() {
no_store = false;
}
FastTransactionServer(const FastTransactionServer&) = delete;
FastTransactionServer& operator=(const FastTransactionServer&) = delete;
~FastTransactionServer() = default;
void set_no_store(bool value) { no_store = value; }
static void FastNoStoreHandler(const HttpRequestInfo* request,
std::string* response_status,
std::string* response_headers,
std::string* response_data) {
if (no_store)
*response_headers = "Cache-Control: no-store\n";
}
private:
static bool no_store;
};
bool FastTransactionServer::no_store;
const MockTransaction kFastNoStoreGET_Transaction = {
"http://www.google.com/nostore",
"GET",
base::Time(),
"",
LOAD_VALIDATE_CACHE,
DefaultTransportInfo(),
"HTTP/1.1 200 OK",
"Cache-Control: max-age=10000\n",
base::Time(),
"<html><body>Google Blah Blah</body></html>",
{},
absl::nullopt,
absl::nullopt,
TEST_MODE_SYNC_NET_START,
&FastTransactionServer::FastNoStoreHandler,
nullptr,
nullptr,
0,
0,
OK,
};
// This class provides a handler for kRangeGET_TransactionOK so that the range
// request can be served on demand.
class RangeTransactionServer {
public:
RangeTransactionServer() {
not_modified_ = false;
modified_ = false;
bad_200_ = false;
redirect_ = false;
length_ = 80;
}
RangeTransactionServer(const RangeTransactionServer&) = delete;
RangeTransactionServer& operator=(const RangeTransactionServer&) = delete;
~RangeTransactionServer() {
not_modified_ = false;
modified_ = false;
bad_200_ = false;
redirect_ = false;
length_ = 80;
}
// Returns only 416 or 304 when set.
void set_not_modified(bool value) { not_modified_ = value; }
// Returns 206 when revalidating a range (instead of 304).
void set_modified(bool value) { modified_ = value; }
// Returns 200 instead of 206 (a malformed response overall).
void set_bad_200(bool value) { bad_200_ = value; }
// Sets how long the resource is. (Default is 80)
void set_length(int64_t length) { length_ = length; }
// Sets whether to return a 301 instead of normal return.
void set_redirect(bool redirect) { redirect_ = redirect; }
// Other than regular range related behavior (and the flags mentioned above),
// the server reacts to requests headers like so:
// X-Require-Mock-Auth -> return 401.
// X-Require-Mock-Auth-Alt -> return 401.
// X-Return-Default-Range -> assume 40-49 was requested.
// The -Alt variant doesn't cause the MockNetworkTransaction to
// report that it IsReadyToRestartForAuth().
static void RangeHandler(const HttpRequestInfo* request,
std::string* response_status,
std::string* response_headers,
std::string* response_data);
private:
static bool not_modified_;
static bool modified_;
static bool bad_200_;
static bool redirect_;
static int64_t length_;
};
bool RangeTransactionServer::not_modified_ = false;
bool RangeTransactionServer::modified_ = false;
bool RangeTransactionServer::bad_200_ = false;
bool RangeTransactionServer::redirect_ = false;
int64_t RangeTransactionServer::length_ = 80;
// A dummy extra header that must be preserved on a given request.
// EXTRA_HEADER_LINE doesn't include a line terminator because it
// will be passed to AddHeaderFromString() which doesn't accept them.
#define EXTRA_HEADER_LINE "Extra: header"
// EXTRA_HEADER contains a line terminator, as expected by
// AddHeadersFromString() (_not_ AddHeaderFromString()).
#define EXTRA_HEADER EXTRA_HEADER_LINE "\r\n"
static const char kExtraHeaderKey[] = "Extra";
// Static.
void RangeTransactionServer::RangeHandler(const HttpRequestInfo* request,
std::string* response_status,
std::string* response_headers,
std::string* response_data) {
if (request->extra_headers.IsEmpty()) {
response_status->assign("HTTP/1.1 416 Requested Range Not Satisfiable");
response_data->clear();
return;
}
// We want to make sure we don't delete extra headers.
EXPECT_TRUE(request->extra_headers.HasHeader(kExtraHeaderKey));
bool require_auth =
request->extra_headers.HasHeader("X-Require-Mock-Auth") ||
request->extra_headers.HasHeader("X-Require-Mock-Auth-Alt");
if (require_auth && !request->extra_headers.HasHeader("Authorization")) {
response_status->assign("HTTP/1.1 401 Unauthorized");
response_data->assign("WWW-Authenticate: Foo\n");
return;
}
if (redirect_) {
response_status->assign("HTTP/1.1 301 Moved Permanently");
response_headers->assign("Location: /elsewhere\nContent-Length: 5");
response_data->assign("12345");
return;
}
if (not_modified_) {
response_status->assign("HTTP/1.1 304 Not Modified");
response_data->clear();
return;
}
std::vector<HttpByteRange> ranges;
std::string range_header;
if (!request->extra_headers.GetHeader(HttpRequestHeaders::kRange,
&range_header) ||
!HttpUtil::ParseRangeHeader(range_header, &ranges) || bad_200_ ||
ranges.size() != 1 ||
(modified_ && request->extra_headers.HasHeader("If-Range"))) {
// This is not a byte range request, or a failed If-Range. We return 200.
response_status->assign("HTTP/1.1 200 OK");
response_headers->assign("Date: Wed, 28 Nov 2007 09:40:09 GMT");
response_data->assign("Not a range");
return;
}
// We can handle this range request.
HttpByteRange byte_range = ranges[0];
if (request->extra_headers.HasHeader("X-Return-Default-Range")) {
byte_range.set_first_byte_position(40);
byte_range.set_last_byte_position(49);
}
if (byte_range.first_byte_position() >= length_) {
response_status->assign("HTTP/1.1 416 Requested Range Not Satisfiable");
response_data->clear();
return;
}
EXPECT_TRUE(byte_range.ComputeBounds(length_));
int64_t start = byte_range.first_byte_position();
int64_t end = byte_range.last_byte_position();
EXPECT_LT(end, length_);
std::string content_range = base::StringPrintf("Content-Range: bytes %" PRId64
"-%" PRId64 "/%" PRId64 "\n",
start, end, length_);
response_headers->append(content_range);
if (!request->extra_headers.HasHeader("If-None-Match") || modified_) {
std::string data;
if (end == start) {
EXPECT_EQ(0, end % 10);
data = "r";
} else {
EXPECT_EQ(9, (end - start) % 10);
for (int64_t block_start = start; block_start < end; block_start += 10) {
base::StringAppendF(&data, "rg: %02" PRId64 "-%02" PRId64 " ",
block_start % 100, (block_start + 9) % 100);
}
}
*response_data = data;
if (end - start != 9) {
// We also have to fix content-length.
int64_t len = end - start + 1;
std::string content_length =
base::StringPrintf("Content-Length: %" PRId64 "\n", len);
response_headers->replace(response_headers->find("Content-Length:"),
content_length.size(), content_length);
}
} else {
response_status->assign("HTTP/1.1 304 Not Modified");
response_data->clear();
}
}
const MockTransaction kRangeGET_TransactionOK = {
"http://www.google.com/range",
"GET",
base::Time(),
"Range: bytes = 40-49\r\n" EXTRA_HEADER,
LOAD_NORMAL,
DefaultTransportInfo(),
"HTTP/1.1 206 Partial Content",
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
"Content-Length: 10\n",
base::Time(),
"rg: 40-49 ",
{},
absl::nullopt,
absl::nullopt,
TEST_MODE_NORMAL,
&RangeTransactionServer::RangeHandler,
nullptr,
nullptr,
0,
0,
OK,
};
const char kFullRangeData[] =
"rg: 00-09 rg: 10-19 rg: 20-29 rg: 30-39 "
"rg: 40-49 rg: 50-59 rg: 60-69 rg: 70-79 ";
// Verifies the response headers (|response|) match a partial content
// response for the range starting at |start| and ending at |end|.
void Verify206Response(const std::string& response, int start, int end) {
auto headers = base::MakeRefCounted<HttpResponseHeaders>(
HttpUtil::AssembleRawHeaders(response));
ASSERT_EQ(206, headers->response_code());
int64_t range_start, range_end, object_size;
ASSERT_TRUE(
headers->GetContentRangeFor206(&range_start, &range_end, &object_size));
int64_t content_length = headers->GetContentLength();
int length = end - start + 1;
ASSERT_EQ(length, content_length);
ASSERT_EQ(start, range_start);
ASSERT_EQ(end, range_end);
}
// Creates a truncated entry that can be resumed using byte ranges.
void CreateTruncatedEntry(std::string raw_headers, MockHttpCache* cache) {
// Create a disk cache entry that stores an incomplete resource.
disk_cache::Entry* entry;
MockHttpRequest request(kRangeGET_TransactionOK);
ASSERT_TRUE(cache->CreateBackendEntry(request.CacheKey(), &entry, nullptr));
HttpResponseInfo response;
response.response_time = base::Time::Now();
response.request_time = base::Time::Now();
response.headers = base::MakeRefCounted<HttpResponseHeaders>(
HttpUtil::AssembleRawHeaders(raw_headers));
// Set the last argument for this to be an incomplete request.
EXPECT_TRUE(MockHttpCache::WriteResponseInfo(entry, &response, true, true));
scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(100);
int len = static_cast<int>(base::strlcpy(buf->data(),
"rg: 00-09 rg: 10-19 ", 100));
TestCompletionCallback cb;
int rv = entry->WriteData(1, 0, buf.get(), len, cb.callback(), true);
EXPECT_EQ(len, cb.GetResult(rv));
entry->Close();
}
// Verifies that there's an entry with this |key| with the truncated flag set to
// |flag_value|, and with an optional |data_size| (if not zero).
void VerifyTruncatedFlag(MockHttpCache* cache,
const std::string& key,
bool flag_value,
int data_size) {
disk_cache::Entry* entry;
ASSERT_TRUE(cache->OpenBackendEntry(key, &entry));
disk_cache::ScopedEntryPtr closer(entry);
HttpResponseInfo response;
bool truncated = !flag_value;
EXPECT_TRUE(MockHttpCache::ReadResponseInfo(entry, &response, &truncated));
EXPECT_EQ(flag_value, truncated);
if (data_size)
EXPECT_EQ(data_size, entry->GetDataSize(1));
}
// Helper to represent a network HTTP response.
struct Response {
// Set this response into |trans|.
void AssignTo(MockTransaction* trans) const {
trans->status = status;
trans->response_headers = headers;
trans->data = body;
}
std::string status_and_headers() const {
return std::string(status) + "\n" + std::string(headers);
}
const char* status;
const char* headers;
const char* body;
};
struct Context {
Context() = default;
int result = ERR_IO_PENDING;
TestCompletionCallback callback;
std::unique_ptr<HttpTransaction> trans;
};
class FakeWebSocketHandshakeStreamCreateHelper
: public WebSocketHandshakeStreamBase::CreateHelper {
public:
~FakeWebSocketHandshakeStreamCreateHelper() override = default;
std::unique_ptr<WebSocketHandshakeStreamBase> CreateBasicStream(
std::unique_ptr<ClientSocketHandle> connect,
bool using_proxy,
WebSocketEndpointLockManager* websocket_endpoint_lock_manager) override {
return nullptr;
}
std::unique_ptr<WebSocketHandshakeStreamBase> CreateHttp2Stream(
base::WeakPtr<SpdySession> session,
std::set<std::string> dns_aliases) override {
NOTREACHED();
return nullptr;
}
std::unique_ptr<WebSocketHandshakeStreamBase> CreateHttp3Stream(
std::unique_ptr<QuicChromiumClientSession::Handle> session,
std::set<std::string> dns_aliases) override {
NOTREACHED();
return nullptr;
}
};
// Returns true if |entry| is not one of the log types paid attention to in this
// test. Note that HTTP_CACHE_WRITE_INFO and HTTP_CACHE_*_DATA are
// ignored.
bool ShouldIgnoreLogEntry(const NetLogEntry& entry) {
switch (entry.type) {
case NetLogEventType::HTTP_CACHE_GET_BACKEND:
case NetLogEventType::HTTP_CACHE_OPEN_OR_CREATE_ENTRY:
case NetLogEventType::HTTP_CACHE_OPEN_ENTRY:
case NetLogEventType::HTTP_CACHE_CREATE_ENTRY:
case NetLogEventType::HTTP_CACHE_ADD_TO_ENTRY:
case NetLogEventType::HTTP_CACHE_DOOM_ENTRY:
case NetLogEventType::HTTP_CACHE_READ_INFO:
return false;
default:
return true;
}
}
// Gets the entries from |net_log| created by the cache layer and asserted on in
// these tests.
std::vector<NetLogEntry> GetFilteredNetLogEntries(
const RecordingNetLogObserver& net_log_observer) {
auto entries = net_log_observer.GetEntries();
base::EraseIf(entries, ShouldIgnoreLogEntry);
return entries;
}
bool LogContainsEventType(const RecordingNetLogObserver& net_log_observer,
NetLogEventType expected) {
return !net_log_observer.GetEntriesWithType(expected).empty();
}
// Returns a TransportInfo distinct from the default for mock transactions,
// with the given port number.
TransportInfo TestTransportInfoWithPort(uint16_t port) {
TransportInfo result;
result.endpoint = IPEndPoint(IPAddress(42, 0, 1, 2), port);
return result;
}
// Returns a TransportInfo distinct from the default for mock transactions.
TransportInfo TestTransportInfo() {
return TestTransportInfoWithPort(1337);
}
TransportInfo CachedTestTransportInfo() {
TransportInfo result = TestTransportInfo();
result.type = TransportType::kCached;
return result;
}
// Helper function, generating valid HTTP cache key from `url`.
// See also: HttpCache::GenerateCacheKey(..)
std::string GenerateCacheKey(const std::string& url) {
return "1/0/" + url;
}
} // namespace
using HttpCacheTest = TestWithTaskEnvironment;
class HttpCacheIOCallbackTest : public HttpCacheTest {
public:
HttpCacheIOCallbackTest() = default;
~HttpCacheIOCallbackTest() override = default;
// HttpCache::ActiveEntry is private, doing this allows tests to use it
using ActiveEntry = HttpCache::ActiveEntry;
using Transaction = HttpCache::Transaction;
// The below functions are forwarding calls to the HttpCache class.
int OpenEntry(HttpCache* cache,
const std::string& url,
HttpCache::ActiveEntry** entry,
HttpCache::Transaction* trans) {
return cache->OpenEntry(GenerateCacheKey(url), entry, trans);
}
int OpenOrCreateEntry(HttpCache* cache,
const std::string& url,
HttpCache::ActiveEntry** entry,
HttpCache::Transaction* trans) {
return cache->OpenOrCreateEntry(GenerateCacheKey(url), entry, trans);
}
int CreateEntry(HttpCache* cache,
const std::string& url,
HttpCache::ActiveEntry** entry,
HttpCache::Transaction* trans) {
return cache->CreateEntry(GenerateCacheKey(url), entry, trans);
}
int DoomEntry(HttpCache* cache,
const std::string& url,
HttpCache::Transaction* trans) {
return cache->DoomEntry(GenerateCacheKey(url), trans);
}
void DeactivateEntry(HttpCache* cache, ActiveEntry* entry) {
cache->DeactivateEntry(entry);
}
};
class HttpSplitCacheKeyTest : public HttpCacheTest {
public:
HttpSplitCacheKeyTest() = default;
~HttpSplitCacheKeyTest() override = default;
std::string ComputeCacheKey(const std::string& url_string) {
GURL url(url_string);
SchemefulSite site(url);
net::HttpRequestInfo request_info;
request_info.url = url;
request_info.method = "GET";
request_info.network_isolation_key = net::NetworkIsolationKey(site, site);
request_info.network_anonymization_key =
net::NetworkAnonymizationKey::CreateSameSite(site);
MockHttpCache cache;
return *cache.http_cache()->GenerateCacheKeyForRequest(&request_info);
}
};
//-----------------------------------------------------------------------------
// Tests.
TEST_F(HttpCacheTest, CreateThenDestroy) {
MockHttpCache cache;
std::unique_ptr<HttpTransaction> trans;
EXPECT_THAT(cache.CreateTransaction(&trans), IsOk());
ASSERT_TRUE(trans.get());
}
TEST_F(HttpCacheTest, GetBackend) {
MockHttpCache cache(HttpCache::DefaultBackend::InMemory(0));
disk_cache::Backend* backend;
TestCompletionCallback cb;
// This will lazily initialize the backend.
int rv = cache.http_cache()->GetBackend(&backend, cb.callback());
EXPECT_THAT(cb.GetResult(rv), IsOk());
}
TEST_F(HttpCacheTest, SimpleGET) {
MockHttpCache cache;
LoadTimingInfo load_timing_info;
// Write to the cache.
RunTransactionTestAndGetTiming(cache.http_cache(), kSimpleGET_Transaction,
NetLogWithSource::Make(NetLogSourceType::NONE),
&load_timing_info);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
TestLoadTimingNetworkRequest(load_timing_info);
}
// This test verifies that the callback passed to SetConnectedCallback() is
// called once for simple GET calls that traverse the cache.
TEST_F(HttpCacheTest, SimpleGET_ConnectedCallback) {
MockHttpCache cache;
ScopedMockTransaction mock_transaction(kSimpleGET_Transaction);
mock_transaction.transport_info = TestTransportInfo();
MockHttpRequest request(mock_transaction);
ConnectedHandler connected_handler;
std::unique_ptr<HttpTransaction> transaction;
EXPECT_THAT(cache.CreateTransaction(&transaction), IsOk());
ASSERT_THAT(transaction, NotNull());
transaction->SetConnectedCallback(connected_handler.Callback());
TestCompletionCallback callback;
ASSERT_THAT(
transaction->Start(&request, callback.callback(), NetLogWithSource()),
IsError(ERR_IO_PENDING));
EXPECT_THAT(callback.WaitForResult(), IsOk());
EXPECT_THAT(connected_handler.transports(), ElementsAre(TestTransportInfo()));
}
// This test verifies that when the callback passed to SetConnectedCallback()
// returns an error, the transaction fails with that error.
TEST_F(HttpCacheTest, SimpleGET_ConnectedCallbackReturnError) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
ConnectedHandler connected_handler;
std::unique_ptr<HttpTransaction> transaction;
EXPECT_THAT(cache.CreateTransaction(&transaction), IsOk());
ASSERT_THAT(transaction, NotNull());
// The exact error code does not matter. We only care that it is passed to
// the transaction's completion callback unmodified.
connected_handler.set_result(ERR_NOT_IMPLEMENTED);
transaction->SetConnectedCallback(connected_handler.Callback());
TestCompletionCallback callback;
ASSERT_THAT(
transaction->Start(&request, callback.callback(), NetLogWithSource()),
IsError(ERR_IO_PENDING));
EXPECT_THAT(callback.WaitForResult(), IsError(ERR_NOT_IMPLEMENTED));
}
// This test verifies that the callback passed to SetConnectedCallback() is
// called once for requests that hit the cache.
TEST_F(HttpCacheTest, SimpleGET_ConnectedCallbackOnCacheHit) {
MockHttpCache cache;
{
// Populate the cache.
ScopedMockTransaction mock_transaction(kSimpleGET_Transaction);
mock_transaction.transport_info = TestTransportInfo();
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
}
// Establish a baseline.
EXPECT_EQ(1, cache.network_layer()->transaction_count());
// Load from the cache (only), observe the callback being called.
ConnectedHandler connected_handler;
MockHttpRequest request(kSimpleGET_Transaction);
std::unique_ptr<HttpTransaction> transaction;
EXPECT_THAT(cache.CreateTransaction(&transaction), IsOk());
ASSERT_THAT(transaction, NotNull());
transaction->SetConnectedCallback(connected_handler.Callback());
TestCompletionCallback callback;
ASSERT_THAT(
transaction->Start(&request, callback.callback(), NetLogWithSource()),
IsError(ERR_IO_PENDING));
EXPECT_THAT(callback.WaitForResult(), IsOk());
// Still only 1 transaction for the previous request. The connected callback
// was not called by a second network transaction.
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_THAT(connected_handler.transports(),
ElementsAre(CachedTestTransportInfo()));
}
// This test verifies that when the callback passed to SetConnectedCallback()
// is called for a request that hit the cache and returns an error, the cache
// entry is reusable.
TEST_F(HttpCacheTest, SimpleGET_ConnectedCallbackOnCacheHitReturnError) {
MockHttpCache cache;
{
// Populate the cache.
ScopedMockTransaction mock_transaction(kSimpleGET_Transaction);
mock_transaction.transport_info = TestTransportInfo();
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
}
MockHttpRequest request(kSimpleGET_Transaction);
{
// Attempt to read from cache entry, but abort transaction due to a
// connected callback error.
ConnectedHandler connected_handler;
connected_handler.set_result(ERR_FAILED);
std::unique_ptr<HttpTransaction> transaction;
EXPECT_THAT(cache.CreateTransaction(&transaction), IsOk());
ASSERT_THAT(transaction, NotNull());
transaction->SetConnectedCallback(connected_handler.Callback());
TestCompletionCallback callback;
ASSERT_THAT(
transaction->Start(&request, callback.callback(), NetLogWithSource()),
IsError(ERR_IO_PENDING));
EXPECT_THAT(callback.WaitForResult(), IsError(ERR_FAILED));
// Used the cache entry only.
EXPECT_THAT(connected_handler.transports(),
ElementsAre(CachedTestTransportInfo()));
}
{
// Request the same resource once more, observe that it is read from cache.
ConnectedHandler connected_handler;
std::unique_ptr<HttpTransaction> transaction;
EXPECT_THAT(cache.CreateTransaction(&transaction), IsOk());
ASSERT_THAT(transaction, NotNull());
transaction->SetConnectedCallback(connected_handler.Callback());
TestCompletionCallback callback;
ASSERT_THAT(
transaction->Start(&request, callback.callback(), NetLogWithSource()),
IsError(ERR_IO_PENDING));
EXPECT_THAT(callback.WaitForResult(), IsOk());
// Used the cache entry only.
EXPECT_THAT(connected_handler.transports(),
ElementsAre(CachedTestTransportInfo()));
}
}
// This test verifies that when the callback passed to SetConnectedCallback()
// returns `ERR_INCONSISTENT_IP_ADDRESS_SPACE`, the cache entry is invalidated.
TEST_F(HttpCacheTest,
SimpleGET_ConnectedCallbackOnCacheHitReturnInconsistentIpError) {
MockHttpCache cache;
ScopedMockTransaction mock_transaction(kSimpleGET_Transaction);
mock_transaction.transport_info = TestTransportInfo();
// Populate the cache.
RunTransactionTest(cache.http_cache(), mock_transaction);
MockHttpRequest request(kSimpleGET_Transaction);
{
// Attempt to read from cache entry, but abort transaction due to a
// connected callback error.
ConnectedHandler connected_handler;
connected_handler.set_result(ERR_INCONSISTENT_IP_ADDRESS_SPACE);
std::unique_ptr<HttpTransaction> transaction;
EXPECT_THAT(cache.CreateTransaction(&transaction), IsOk());
ASSERT_THAT(transaction, NotNull());
transaction->SetConnectedCallback(connected_handler.Callback());
TestCompletionCallback callback;
ASSERT_THAT(
transaction->Start(&request, callback.callback(), NetLogWithSource()),
IsError(ERR_IO_PENDING));
EXPECT_THAT(callback.WaitForResult(),
IsError(ERR_INCONSISTENT_IP_ADDRESS_SPACE));
// Used the cache entry only.
EXPECT_THAT(connected_handler.transports(),
ElementsAre(CachedTestTransportInfo()));
}
{
// Request the same resource once more, observe that it is not read from
// cache.
ConnectedHandler connected_handler;
std::unique_ptr<HttpTransaction> transaction;
EXPECT_THAT(cache.CreateTransaction(&transaction), IsOk());
ASSERT_THAT(transaction, NotNull());
transaction->SetConnectedCallback(connected_handler.Callback());
TestCompletionCallback callback;
ASSERT_THAT(
transaction->Start(&request, callback.callback(), NetLogWithSource()),
IsError(ERR_IO_PENDING));
EXPECT_THAT(callback.WaitForResult(), IsOk());
// Used the network only.
EXPECT_THAT(connected_handler.transports(),
ElementsAre(TestTransportInfo()));
}
}
// This test verifies that when the callback passed to SetConnectedCallback()
// returns
// `ERR_CACHED_IP_ADDRESS_SPACE_BLOCKED_BY_LOCAL_NETWORK_ACCESS_POLICY`, the
// cache entry is invalidated, and we'll retry the connection from the network.
TEST_F(
HttpCacheTest,
SimpleGET_ConnectedCallbackOnCacheHitReturnLocalNetworkAccessBlockedError) {
MockHttpCache cache;
ScopedMockTransaction mock_transaction(kSimpleGET_Transaction);
mock_transaction.transport_info = TestTransportInfo();
// Populate the cache.
RunTransactionTest(cache.http_cache(), mock_transaction);
MockHttpRequest request(kSimpleGET_Transaction);
{
// Attempt to read from cache entry, but abort transaction due to a
// connected callback error.
ConnectedHandler connected_handler;
connected_handler.set_result(
ERR_CACHED_IP_ADDRESS_SPACE_BLOCKED_BY_LOCAL_NETWORK_ACCESS_POLICY);
std::unique_ptr<HttpTransaction> transaction;
EXPECT_THAT(cache.CreateTransaction(&transaction), IsOk());
ASSERT_THAT(transaction, NotNull());
transaction->SetConnectedCallback(connected_handler.Callback());
TestCompletionCallback callback;
ASSERT_THAT(
transaction->Start(&request, callback.callback(), NetLogWithSource()),
IsError(ERR_IO_PENDING));
EXPECT_THAT(
callback.WaitForResult(),
IsError(
ERR_CACHED_IP_ADDRESS_SPACE_BLOCKED_BY_LOCAL_NETWORK_ACCESS_POLICY));
// Used the cache entry only.
EXPECT_THAT(connected_handler.transports(),
ElementsAre(CachedTestTransportInfo(), TestTransportInfo()));
}
{
// Request the same resource once more, observe that it is not read from
// cache.
ConnectedHandler connected_handler;
std::unique_ptr<HttpTransaction> transaction;
EXPECT_THAT(cache.CreateTransaction(&transaction), IsOk());
ASSERT_THAT(transaction, NotNull());
transaction->SetConnectedCallback(connected_handler.Callback());
TestCompletionCallback callback;
ASSERT_THAT(
transaction->Start(&request, callback.callback(), NetLogWithSource()),
IsError(ERR_IO_PENDING));
EXPECT_THAT(callback.WaitForResult(), IsOk());
// Used the network only.
EXPECT_THAT(connected_handler.transports(),
ElementsAre(TestTransportInfo()));
}
}
// This test verifies that the callback passed to SetConnectedCallback() is
// called with the right transport type when the cached entry was originally
// fetched via proxy.
TEST_F(HttpCacheTest, SimpleGET_ConnectedCallbackOnCacheHitFromProxy) {
MockHttpCache cache;
TransportInfo proxied_transport_info = TestTransportInfo();
proxied_transport_info.type = TransportType::kProxied;
{
// Populate the cache.
ScopedMockTransaction mock_transaction(kSimpleGET_Transaction);
mock_transaction.transport_info = proxied_transport_info;
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
}
// Establish a baseline.
EXPECT_EQ(1, cache.network_layer()->transaction_count());
// Load from the cache (only), observe the callback being called.
ConnectedHandler connected_handler;
MockHttpRequest request(kSimpleGET_Transaction);
std::unique_ptr<HttpTransaction> transaction;
EXPECT_THAT(cache.CreateTransaction(&transaction), IsOk());
ASSERT_THAT(transaction, NotNull());
transaction->SetConnectedCallback(connected_handler.Callback());
TestCompletionCallback callback;
ASSERT_THAT(
transaction->Start(&request, callback.callback(), NetLogWithSource()),
IsError(ERR_IO_PENDING));
EXPECT_THAT(callback.WaitForResult(), IsOk());
// Still only 1 transaction for the previous request. The connected callback
// was not called by a second network transaction.
EXPECT_EQ(1, cache.network_layer()->transaction_count());
// The transport info mentions both the cache and the original proxy.
TransportInfo expected_transport_info = TestTransportInfo();
expected_transport_info.type = TransportType::kCachedFromProxy;
EXPECT_THAT(connected_handler.transports(),
ElementsAre(expected_transport_info));
}
enum class SplitCacheTestCase {
kSplitCacheDisabled,
kSplitCacheNikFrameSiteEnabled,
kSplitCacheNikCrossSiteFlagEnabled,
};
void InitializeSplitCacheScopedFeatureList(
base::test::ScopedFeatureList& scoped_feature_list,
SplitCacheTestCase test_case) {
std::vector<base::test::FeatureRef> enabled_features;
std::vector<base::test::FeatureRef> disabled_features;
if (test_case == SplitCacheTestCase::kSplitCacheDisabled) {
disabled_features.push_back(
net::features::kSplitCacheByNetworkIsolationKey);
} else {
enabled_features.push_back(net::features::kSplitCacheByNetworkIsolationKey);
}
if (test_case == SplitCacheTestCase::kSplitCacheNikCrossSiteFlagEnabled) {
enabled_features.push_back(
net::features::kEnableCrossSiteFlagNetworkIsolationKey);
} else {
disabled_features.push_back(
net::features::kEnableCrossSiteFlagNetworkIsolationKey);
}
scoped_feature_list.InitWithFeatures(enabled_features, disabled_features);
}
class HttpCacheTest_SplitCacheFeature
: public HttpCacheTest,
public ::testing::WithParamInterface<SplitCacheTestCase> {
public:
HttpCacheTest_SplitCacheFeature() {
InitializeSplitCacheScopedFeatureList(feature_list_, GetParam());
}
bool IsSplitCacheEnabled() const {
return GetParam() != SplitCacheTestCase::kSplitCacheDisabled;
}
bool IsNikFrameSiteEnabled() const {
return GetParam() == SplitCacheTestCase::kSplitCacheNikFrameSiteEnabled;
}
private:
base::test::ScopedFeatureList feature_list_;
};
TEST_P(HttpCacheTest_SplitCacheFeature, SimpleGETVerifyGoogleFontMetrics) {
base::HistogramTester histograms;
const std::string histogram_name = "WebFont.HttpCacheStatus_roboto";
SchemefulSite site_a(GURL("http://www.a.com"));
MockHttpCache cache;
MockTransaction transaction(kSimpleGET_Transaction);
transaction.url = "http://themes.googleusercontent.com/static/fonts/roboto";
AddMockTransaction(&transaction);
MockHttpRequest request(transaction);
request.network_isolation_key = NetworkIsolationKey(site_a, site_a);
request.network_anonymization_key =
net::NetworkAnonymizationKey::CreateSameSite(site_a);
// Attempt to populate the cache.
RunTransactionTestWithRequest(cache.http_cache(), transaction, request,
nullptr);
histograms.ExpectUniqueSample(
histogram_name, static_cast<int>(CacheEntryStatus::ENTRY_NOT_IN_CACHE),
1);
RunTransactionTestWithRequest(cache.http_cache(), transaction, request,
nullptr);
histograms.ExpectBucketCount(
histogram_name, static_cast<int>(CacheEntryStatus::ENTRY_USED), 1);
}
INSTANTIATE_TEST_SUITE_P(
All,
HttpCacheTest_SplitCacheFeature,
testing::ValuesIn({SplitCacheTestCase::kSplitCacheDisabled,
SplitCacheTestCase::kSplitCacheNikFrameSiteEnabled,
SplitCacheTestCase::kSplitCacheNikCrossSiteFlagEnabled}),
[](const testing::TestParamInfo<SplitCacheTestCase>& info) {
switch (info.param) {
case (SplitCacheTestCase::kSplitCacheDisabled):
return "SplitCacheDisabled";
case (SplitCacheTestCase::kSplitCacheNikFrameSiteEnabled):
return "SplitCacheNikFrameSiteEnabled";
case (SplitCacheTestCase::kSplitCacheNikCrossSiteFlagEnabled):
return "SplitCacheNikCrossSiteFlagEnabled";
}
});
class HttpCacheTest_SplitCacheFeatureEnabled
: public HttpCacheTest_SplitCacheFeature {
public:
HttpCacheTest_SplitCacheFeatureEnabled() {
CHECK(base::FeatureList::IsEnabled(
net::features::kSplitCacheByNetworkIsolationKey));
}
};
INSTANTIATE_TEST_SUITE_P(
All,
HttpCacheTest_SplitCacheFeatureEnabled,
testing::ValuesIn({SplitCacheTestCase::kSplitCacheNikFrameSiteEnabled,
SplitCacheTestCase::kSplitCacheNikCrossSiteFlagEnabled}),
[](const testing::TestParamInfo<SplitCacheTestCase>& info) {
switch (info.param) {
case (SplitCacheTestCase::kSplitCacheDisabled):
return "NotUsedForThisTestSuite";
case (SplitCacheTestCase::kSplitCacheNikFrameSiteEnabled):
return "SplitCacheNikFrameSiteEnabled";
case (SplitCacheTestCase::kSplitCacheNikCrossSiteFlagEnabled):
return "SplitCacheNikCrossSiteFlagEnabled";
}
});
TEST_F(HttpCacheTest, SimpleGETNoDiskCache) {
MockHttpCache cache;
cache.disk_cache()->set_fail_requests(true);
RecordingNetLogObserver net_log_observer;
LoadTimingInfo load_timing_info;
// Read from the network, and don't use the cache.
RunTransactionTestAndGetTiming(cache.http_cache(), kSimpleGET_Transaction,
NetLogWithSource::Make(NetLogSourceType::NONE),
&load_timing_info);
// Check that the NetLog was filled as expected.
// (We attempted to OpenOrCreate entries, but fail).
auto entries = GetFilteredNetLogEntries(net_log_observer);
EXPECT_EQ(4u, entries.size());
EXPECT_TRUE(LogContainsBeginEvent(entries, 0,
NetLogEventType::HTTP_CACHE_GET_BACKEND));
EXPECT_TRUE(
LogContainsEndEvent(entries, 1, NetLogEventType::HTTP_CACHE_GET_BACKEND));
EXPECT_TRUE(LogContainsBeginEvent(
entries, 2, NetLogEventType::HTTP_CACHE_OPEN_OR_CREATE_ENTRY));
EXPECT_TRUE(LogContainsEndEvent(
entries, 3, NetLogEventType::HTTP_CACHE_OPEN_OR_CREATE_ENTRY));
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(0, cache.disk_cache()->create_count());
TestLoadTimingNetworkRequest(load_timing_info);
}
TEST_F(HttpCacheTest, SimpleGETNoDiskCache2) {
// This will initialize a cache object with NULL backend.
auto factory = std::make_unique<MockBlockingBackendFactory>();
factory->set_fail(true);
factory->FinishCreation(); // We'll complete synchronously.
MockHttpCache cache(std::move(factory));
// Read from the network, and don't use the cache.
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_FALSE(cache.http_cache()->GetCurrentBackend());
}
// Tests that IOBuffers are not referenced after IO completes.
TEST_F(HttpCacheTest, ReleaseBuffer) {
MockHttpCache cache;
// Write to the cache.
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
MockHttpRequest request(kSimpleGET_Transaction);
std::unique_ptr<HttpTransaction> trans;
ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
const int kBufferSize = 10;
scoped_refptr<IOBuffer> buffer = base::MakeRefCounted<IOBuffer>(kBufferSize);
ReleaseBufferCompletionCallback cb(buffer.get());
int rv = trans->Start(&request, cb.callback(), NetLogWithSource());
EXPECT_THAT(cb.GetResult(rv), IsOk());
rv = trans->Read(buffer.get(), kBufferSize, cb.callback());
EXPECT_EQ(kBufferSize, cb.GetResult(rv));
}
TEST_F(HttpCacheTest, SimpleGETWithDiskFailures) {
MockHttpCache cache;
cache.disk_cache()->set_soft_failures_mask(MockDiskEntry::FAIL_ALL);
// Read from the network, and fail to write to the cache.
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// This one should see an empty cache again.
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests that disk failures after the transaction has started don't cause the
// request to fail.
TEST_F(HttpCacheTest, SimpleGETWithDiskFailures2) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
auto c = std::make_unique<Context>();
int rv = cache.CreateTransaction(&c->trans);
ASSERT_THAT(rv, IsOk());
rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
rv = c->callback.WaitForResult();
// Start failing request now.
cache.disk_cache()->set_soft_failures_mask(MockDiskEntry::FAIL_ALL);
// We have to open the entry again to propagate the failure flag.
disk_cache::Entry* en;
ASSERT_TRUE(cache.OpenBackendEntry(request.CacheKey(), &en));
en->Close();
ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
c.reset();
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// This one should see an empty cache again.
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests that we handle failures to read from the cache.
TEST_F(HttpCacheTest, SimpleGETWithDiskFailures3) {
MockHttpCache cache;
// Read from the network, and write to the cache.
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
cache.disk_cache()->set_soft_failures_mask(MockDiskEntry::FAIL_ALL);
MockHttpRequest request(kSimpleGET_Transaction);
// Now fail to read from the cache.
auto c = std::make_unique<Context>();
int rv = cache.CreateTransaction(&c->trans);
ASSERT_THAT(rv, IsOk());
rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
EXPECT_THAT(c->callback.GetResult(rv), IsOk());
// Now verify that the entry was removed from the cache.
cache.disk_cache()->set_soft_failures_mask(0);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(3, cache.disk_cache()->create_count());
}
TEST_F(HttpCacheTest, SimpleGET_LoadOnlyFromCache_Hit) {
MockHttpCache cache;
RecordingNetLogObserver net_log_observer;
NetLogWithSource net_log_with_source =
NetLogWithSource::Make(NetLogSourceType::NONE);
LoadTimingInfo load_timing_info;
// Write to the cache.
RunTransactionTestAndGetTiming(cache.http_cache(), kSimpleGET_Transaction,
net_log_with_source, &load_timing_info);
// Check that the NetLog was filled as expected.
auto entries = GetFilteredNetLogEntries(net_log_observer);
EXPECT_EQ(6u, entries.size());
EXPECT_TRUE(LogContainsBeginEvent(entries, 0,
NetLogEventType::HTTP_CACHE_GET_BACKEND));
EXPECT_TRUE(
LogContainsEndEvent(entries, 1, NetLogEventType::HTTP_CACHE_GET_BACKEND));
EXPECT_TRUE(LogContainsBeginEvent(
entries, 2, NetLogEventType::HTTP_CACHE_OPEN_OR_CREATE_ENTRY));
EXPECT_TRUE(LogContainsEndEvent(
entries, 3, NetLogEventType::HTTP_CACHE_OPEN_OR_CREATE_ENTRY));
EXPECT_TRUE(LogContainsBeginEvent(entries, 4,
NetLogEventType::HTTP_CACHE_ADD_TO_ENTRY));
EXPECT_TRUE(LogContainsEndEvent(entries, 5,
NetLogEventType::HTTP_CACHE_ADD_TO_ENTRY));
TestLoadTimingNetworkRequest(load_timing_info);
// Force this transaction to read from the cache.
MockTransaction transaction(kSimpleGET_Transaction);
transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
net_log_observer.Clear();
RunTransactionTestAndGetTiming(cache.http_cache(), transaction,
net_log_with_source, &load_timing_info);
// Check that the NetLog was filled as expected.
entries = GetFilteredNetLogEntries(net_log_observer);
EXPECT_EQ(8u, entries.size());
EXPECT_TRUE(LogContainsBeginEvent(entries, 0,
NetLogEventType::HTTP_CACHE_GET_BACKEND));
EXPECT_TRUE(
LogContainsEndEvent(entries, 1, NetLogEventType::HTTP_CACHE_GET_BACKEND));
EXPECT_TRUE(LogContainsBeginEvent(
entries, 2, NetLogEventType::HTTP_CACHE_OPEN_OR_CREATE_ENTRY));
EXPECT_TRUE(LogContainsEndEvent(
entries, 3, NetLogEventType::HTTP_CACHE_OPEN_OR_CREATE_ENTRY));
EXPECT_TRUE(LogContainsBeginEvent(entries, 4,
NetLogEventType::HTTP_CACHE_ADD_TO_ENTRY));
EXPECT_TRUE(LogContainsEndEvent(entries, 5,
NetLogEventType::HTTP_CACHE_ADD_TO_ENTRY));
EXPECT_TRUE(
LogContainsBeginEvent(entries, 6, NetLogEventType::HTTP_CACHE_READ_INFO));
EXPECT_TRUE(
LogContainsEndEvent(entries, 7, NetLogEventType::HTTP_CACHE_READ_INFO));
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
TestLoadTimingCachedResponse(load_timing_info);
}
TEST_F(HttpCacheTest, SimpleGET_LoadOnlyFromCache_Miss) {
MockHttpCache cache;
// force this transaction to read from the cache
MockTransaction transaction(kSimpleGET_Transaction);
transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
MockHttpRequest request(transaction);
TestCompletionCallback callback;
std::unique_ptr<HttpTransaction> trans;
ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
if (rv == ERR_IO_PENDING)
rv = callback.WaitForResult();
ASSERT_THAT(rv, IsError(ERR_CACHE_MISS));
trans.reset();
EXPECT_EQ(0, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(0, cache.disk_cache()->create_count());
}
TEST_F(HttpCacheTest, SimpleGET_LoadPreferringCache_Hit) {
MockHttpCache cache;
// write to the cache
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
// force this transaction to read from the cache if valid
MockTransaction transaction(kSimpleGET_Transaction);
transaction.load_flags |= LOAD_SKIP_CACHE_VALIDATION;
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
TEST_F(HttpCacheTest, SimpleGET_LoadPreferringCache_Miss) {
MockHttpCache cache;
// force this transaction to read from the cache if valid
MockTransaction transaction(kSimpleGET_Transaction);
transaction.load_flags |= LOAD_SKIP_CACHE_VALIDATION;
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Tests LOAD_SKIP_CACHE_VALIDATION in the presence of vary headers.
TEST_F(HttpCacheTest, SimpleGET_LoadPreferringCache_VaryMatch) {
MockHttpCache cache;
// Write to the cache.
MockTransaction transaction(kSimpleGET_Transaction);
transaction.request_headers = "Foo: bar\r\n";
transaction.response_headers = "Cache-Control: max-age=10000\n"
"Vary: Foo\n";
AddMockTransaction(&transaction);
RunTransactionTest(cache.http_cache(), transaction);
// Read from the cache.
transaction.load_flags |= LOAD_SKIP_CACHE_VALIDATION;
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests LOAD_SKIP_CACHE_VALIDATION in the presence of vary headers.
TEST_F(HttpCacheTest, SimpleGET_LoadPreferringCache_VaryMismatch) {
MockHttpCache cache;
// Write to the cache.
MockTransaction transaction(kSimpleGET_Transaction);
transaction.request_headers = "Foo: bar\r\n";
transaction.response_headers = "Cache-Control: max-age=10000\n"
"Vary: Foo\n";
AddMockTransaction(&transaction);
RunTransactionTest(cache.http_cache(), transaction);
// Attempt to read from the cache... this is a vary mismatch that must reach
// the network again.
transaction.load_flags |= LOAD_SKIP_CACHE_VALIDATION;
transaction.request_headers = "Foo: none\r\n";
LoadTimingInfo load_timing_info;
RunTransactionTestAndGetTiming(cache.http_cache(), transaction,
NetLogWithSource::Make(NetLogSourceType::NONE),
&load_timing_info);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
TestLoadTimingNetworkRequest(load_timing_info);
RemoveMockTransaction(&transaction);
}
// Tests that we honor Vary: * with LOAD_SKIP_CACHE_VALIDATION (crbug/778681)
TEST_F(HttpCacheTest, SimpleGET_LoadSkipCacheValidation_VaryStar) {
MockHttpCache cache;
// Write to the cache.
MockTransaction transaction(kSimpleGET_Transaction);
transaction.response_headers =
"Cache-Control: max-age=10000\n"
"Vary: *\n";
AddMockTransaction(&transaction);
RunTransactionTest(cache.http_cache(), transaction);
// Attempt to read from the cache... we will still load it from network,
// since Vary: * doesn't match.
transaction.load_flags |= LOAD_SKIP_CACHE_VALIDATION;
LoadTimingInfo load_timing_info;
RunTransactionTestAndGetTiming(cache.http_cache(), transaction,
NetLogWithSource::Make(NetLogSourceType::NONE),
&load_timing_info);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests that was_cached was set properly on a failure, even if the cached
// response wasn't returned.
TEST_F(HttpCacheTest, SimpleGET_CacheSignal_Failure) {
for (bool use_memory_entry_data : {false, true}) {
MockHttpCache cache;
cache.disk_cache()->set_support_in_memory_entry_data(use_memory_entry_data);
// Prime cache.
MockTransaction transaction(kSimpleGET_Transaction);
transaction.response_headers = "Cache-Control: no-cache\n";
AddMockTransaction(&transaction);
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
RemoveMockTransaction(&transaction);
// Network failure with error; should fail but have was_cached set.
transaction.start_return_code = ERR_FAILED;
AddMockTransaction(&transaction);
MockHttpRequest request(transaction);
TestCompletionCallback callback;
std::unique_ptr<HttpTransaction> trans;
int rv = cache.http_cache()->CreateTransaction(DEFAULT_PRIORITY, &trans);
EXPECT_THAT(rv, IsOk());
ASSERT_TRUE(trans.get());
rv = trans->Start(&request, callback.callback(), NetLogWithSource());
EXPECT_THAT(callback.GetResult(rv), IsError(ERR_FAILED));
const HttpResponseInfo* response_info = trans->GetResponseInfo();
ASSERT_TRUE(response_info);
// If use_memory_entry_data is true, we will not bother opening the entry,
// and just kick it out, so was_cached will end up false.
EXPECT_EQ(2, cache.network_layer()->transaction_count());
if (use_memory_entry_data) {
EXPECT_EQ(false, response_info->was_cached);
EXPECT_EQ(2, cache.disk_cache()->create_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
} else {
EXPECT_EQ(true, response_info->was_cached);
EXPECT_EQ(1, cache.disk_cache()->create_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
}
RemoveMockTransaction(&transaction);
}
}
// Tests that if the transaction is destroyed right after setting the
// cache_entry_status_ as CANT_CONDITIONALIZE, then RecordHistograms should not
// hit a dcheck.
TEST_F(HttpCacheTest, RecordHistogramsCantConditionalize) {
MockHttpCache cache;
cache.disk_cache()->set_support_in_memory_entry_data(true);
{
// Prime cache.
ScopedMockTransaction transaction(kSimpleGET_Transaction);
transaction.response_headers = "Cache-Control: no-cache\n";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
}
{
ScopedMockTransaction transaction(kSimpleGET_Transaction);
MockHttpRequest request(transaction);
TestCompletionCallback callback;
std::unique_ptr<HttpTransaction> trans;
int rv = cache.http_cache()->CreateTransaction(DEFAULT_PRIORITY, &trans);
EXPECT_THAT(rv, IsOk());
ASSERT_TRUE(trans.get());
rv = trans->Start(&request, callback.callback(), NetLogWithSource());
// Now destroy the transaction so that RecordHistograms gets invoked.
trans.reset();
}
}
// Confirm if we have an empty cache, a read is marked as network verified.
TEST_F(HttpCacheTest, SimpleGET_NetworkAccessed_Network) {
MockHttpCache cache;
// write to the cache
HttpResponseInfo response_info;
RunTransactionTestWithResponseInfo(cache.http_cache(), kSimpleGET_Transaction,
&response_info);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
EXPECT_TRUE(response_info.network_accessed);
EXPECT_EQ(CacheEntryStatus::ENTRY_NOT_IN_CACHE,
response_info.cache_entry_status);
}
// Confirm if we have a fresh entry in cache, it isn't marked as
// network verified.
TEST_F(HttpCacheTest, SimpleGET_NetworkAccessed_Cache) {
MockHttpCache cache;
// Prime cache.
MockTransaction transaction(kSimpleGET_Transaction);
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Re-run transaction; make sure we don't mark the network as accessed.
HttpResponseInfo response_info;
RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
&response_info);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_FALSE(response_info.network_accessed);
EXPECT_EQ(CacheEntryStatus::ENTRY_USED, response_info.cache_entry_status);
}
TEST_F(HttpCacheTest, SimpleGET_LoadBypassCache) {
MockHttpCache cache;
// Write to the cache.
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
// Force this transaction to write to the cache again.
MockTransaction transaction(kSimpleGET_Transaction);
transaction.load_flags |= LOAD_BYPASS_CACHE;
RecordingNetLogObserver net_log_observer;
LoadTimingInfo load_timing_info;
// Write to the cache.
RunTransactionTestAndGetTiming(cache.http_cache(), transaction,
NetLogWithSource::Make(NetLogSourceType::NONE),
&load_timing_info);
// Check that the NetLog was filled as expected.
auto entries = GetFilteredNetLogEntries(net_log_observer);
EXPECT_EQ(8u, entries.size());
EXPECT_TRUE(LogContainsBeginEvent(entries, 0,
NetLogEventType::HTTP_CACHE_GET_BACKEND));
EXPECT_TRUE(
LogContainsEndEvent(entries, 1, NetLogEventType::HTTP_CACHE_GET_BACKEND));
EXPECT_TRUE(LogContainsBeginEvent(entries, 2,
NetLogEventType::HTTP_CACHE_DOOM_ENTRY));
EXPECT_TRUE(
LogContainsEndEvent(entries, 3, NetLogEventType::HTTP_CACHE_DOOM_ENTRY));
EXPECT_TRUE(LogContainsBeginEvent(entries, 4,
NetLogEventType::HTTP_CACHE_CREATE_ENTRY));
EXPECT_TRUE(LogContainsEndEvent(entries, 5,
NetLogEventType::HTTP_CACHE_CREATE_ENTRY));
EXPECT_TRUE(LogContainsBeginEvent(entries, 6,
NetLogEventType::HTTP_CACHE_ADD_TO_ENTRY));
EXPECT_TRUE(LogContainsEndEvent(entries, 7,
NetLogEventType::HTTP_CACHE_ADD_TO_ENTRY));
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
TestLoadTimingNetworkRequest(load_timing_info);
}
TEST_F(HttpCacheTest, SimpleGET_LoadBypassCache_Implicit) {
MockHttpCache cache;
// write to the cache
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
// force this transaction to write to the cache again
MockTransaction transaction(kSimpleGET_Transaction);
transaction.request_headers = "pragma: no-cache\r\n";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
TEST_F(HttpCacheTest, SimpleGET_LoadBypassCache_Implicit2) {
MockHttpCache cache;
// write to the cache
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
// force this transaction to write to the cache again
MockTransaction transaction(kSimpleGET_Transaction);
transaction.request_headers = "cache-control: no-cache\r\n";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
TEST_F(HttpCacheTest, SimpleGET_LoadValidateCache) {
MockHttpCache cache;
// Write to the cache.
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
// Read from the cache.
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
// Force this transaction to validate the cache.
MockTransaction transaction(kSimpleGET_Transaction);
transaction.load_flags |= LOAD_VALIDATE_CACHE;
HttpResponseInfo response_info;
LoadTimingInfo load_timing_info;
RunTransactionTestWithResponseInfoAndGetTiming(
cache.http_cache(), transaction, &response_info,
NetLogWithSource::Make(NetLogSourceType::NONE), &load_timing_info);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
EXPECT_TRUE(response_info.network_accessed);
TestLoadTimingNetworkRequest(load_timing_info);
}
TEST_F(HttpCacheTest, SimpleGET_LoadValidateCache_Implicit) {
MockHttpCache cache;
// write to the cache
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
// read from the cache
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
// force this transaction to validate the cache
MockTransaction transaction(kSimpleGET_Transaction);
transaction.request_headers = "cache-control: max-age=0\r\n";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Tests that |unused_since_prefetch| is updated accordingly (e.g. it is set to
// true after a prefetch and set back to false when the prefetch is used).
TEST_F(HttpCacheTest, SimpleGET_UnusedSincePrefetch) {
MockHttpCache cache;
HttpResponseInfo response_info;
// A normal load does not have |unused_since_prefetch| set.
RunTransactionTestWithResponseInfoAndGetTiming(
cache.http_cache(), kSimpleGET_Transaction, &response_info,
NetLogWithSource::Make(NetLogSourceType::NONE), nullptr);
EXPECT_FALSE(response_info.unused_since_prefetch);
EXPECT_FALSE(response_info.was_cached);
// The prefetch itself does not have |unused_since_prefetch| set.
MockTransaction prefetch_transaction(kSimpleGET_Transaction);
prefetch_transaction.load_flags |= LOAD_PREFETCH;
RunTransactionTestWithResponseInfoAndGetTiming(
cache.http_cache(), prefetch_transaction, &response_info,
NetLogWithSource::Make(NetLogSourceType::NONE), nullptr);
EXPECT_FALSE(response_info.unused_since_prefetch);
EXPECT_TRUE(response_info.was_cached);
// A duplicated prefetch has |unused_since_prefetch| set.
RunTransactionTestWithResponseInfoAndGetTiming(
cache.http_cache(), prefetch_transaction, &response_info,
NetLogWithSource::Make(NetLogSourceType::NONE), nullptr);
EXPECT_TRUE(response_info.unused_since_prefetch);
EXPECT_TRUE(response_info.was_cached);
// |unused_since_prefetch| is still true after two prefetches in a row.
RunTransactionTestWithResponseInfoAndGetTiming(
cache.http_cache(), kSimpleGET_Transaction, &response_info,
NetLogWithSource::Make(NetLogSourceType::NONE), nullptr);
EXPECT_TRUE(response_info.unused_since_prefetch);
EXPECT_TRUE(response_info.was_cached);
// The resource has now been used, back to normal behavior.
RunTransactionTestWithResponseInfoAndGetTiming(
cache.http_cache(), kSimpleGET_Transaction, &response_info,
NetLogWithSource::Make(NetLogSourceType::NONE), nullptr);
EXPECT_FALSE(response_info.unused_since_prefetch);
EXPECT_TRUE(response_info.was_cached);
}
// Tests that requests made with the LOAD_RESTRICTED_PREFETCH load flag result
// in HttpResponseInfo entries with the |restricted_prefetch| flag set. Also
// tests that responses with |restricted_prefetch| flag set can only be used by
// requests that have the LOAD_CAN_USE_RESTRICTED_PREFETCH load flag.
TEST_F(HttpCacheTest, SimpleGET_RestrictedPrefetchIsRestrictedUntilReuse) {
MockHttpCache cache;
HttpResponseInfo response_info;
// A normal load does not have |restricted_prefetch| set.
RunTransactionTestWithResponseInfoAndGetTiming(
cache.http_cache(), kTypicalGET_Transaction, &response_info,
NetLogWithSource::Make(NetLogSourceType::NONE), nullptr);
EXPECT_FALSE(response_info.restricted_prefetch);
EXPECT_FALSE(response_info.was_cached);
EXPECT_TRUE(response_info.network_accessed);
// A restricted prefetch is marked as |restricted_prefetch|.
MockTransaction prefetch_transaction(kSimpleGET_Transaction);
prefetch_transaction.load_flags |= LOAD_PREFETCH;
prefetch_transaction.load_flags |= LOAD_RESTRICTED_PREFETCH;
RunTransactionTestWithResponseInfoAndGetTiming(
cache.http_cache(), prefetch_transaction, &response_info,
NetLogWithSource::Make(NetLogSourceType::NONE), nullptr);
EXPECT_TRUE(response_info.restricted_prefetch);
EXPECT_FALSE(response_info.was_cached);
EXPECT_TRUE(response_info.network_accessed);
// Requests that are marked as able to reuse restricted prefetches can do so
// correctly. Once it is reused, it is no longer considered as or marked
// restricted.
MockTransaction can_use_restricted_prefetch_transaction(
kSimpleGET_Transaction);
can_use_restricted_prefetch_transaction.load_flags |=
LOAD_CAN_USE_RESTRICTED_PREFETCH;
RunTransactionTestWithResponseInfoAndGetTiming(
cache.http_cache(), can_use_restricted_prefetch_transaction,
&response_info, NetLogWithSource::Make(NetLogSourceType::NONE), nullptr);
EXPECT_TRUE(response_info.restricted_prefetch);
EXPECT_TRUE(response_info.was_cached);
EXPECT_FALSE(response_info.network_accessed);
// Later reuse is still no longer marked restricted.
RunTransactionTestWithResponseInfoAndGetTiming(
cache.http_cache(), kSimpleGET_Transaction, &response_info,
NetLogWithSource::Make(NetLogSourceType::NONE), nullptr);
EXPECT_FALSE(response_info.restricted_prefetch);
EXPECT_TRUE(response_info.was_cached);
EXPECT_FALSE(response_info.network_accessed);
}
TEST_F(HttpCacheTest, SimpleGET_RestrictedPrefetchReuseIsLimited) {
MockHttpCache cache;
HttpResponseInfo response_info;
// A restricted prefetch is marked as |restricted_prefetch|.
MockTransaction prefetch_transaction(kSimpleGET_Transaction);
prefetch_transaction.load_flags |= LOAD_PREFETCH;
prefetch_transaction.load_flags |= LOAD_RESTRICTED_PREFETCH;
RunTransactionTestWithResponseInfoAndGetTiming(
cache.http_cache(), prefetch_transaction, &response_info,
NetLogWithSource::Make(NetLogSourceType::NONE), nullptr);
EXPECT_TRUE(response_info.restricted_prefetch);
EXPECT_FALSE(response_info.was_cached);
EXPECT_TRUE(response_info.network_accessed);
// Requests that cannot reuse restricted prefetches fail to do so. The network
// is accessed and the resulting response is not marked as
// |restricted_prefetch|.
RunTransactionTestWithResponseInfoAndGetTiming(
cache.http_cache(), kSimpleGET_Transaction, &response_info,
NetLogWithSource::Make(NetLogSourceType::NONE), nullptr);
EXPECT_FALSE(response_info.restricted_prefetch);
EXPECT_FALSE(response_info.was_cached);
EXPECT_TRUE(response_info.network_accessed);
// Future requests that are not marked as able to reuse restricted prefetches
// can use the entry in the cache now, since it has been evicted in favor of
// an unrestricted one.
RunTransactionTestWithResponseInfoAndGetTiming(
cache.http_cache(), kSimpleGET_Transaction, &response_info,
NetLogWithSource::Make(NetLogSourceType::NONE), nullptr);
EXPECT_FALSE(response_info.restricted_prefetch);
EXPECT_TRUE(response_info.was_cached);
EXPECT_FALSE(response_info.network_accessed);
}
TEST_F(HttpCacheTest, SimpleGET_UnusedSincePrefetchWriteError) {
MockHttpCache cache;
HttpResponseInfo response_info;
// Do a prefetch.
MockTransaction prefetch_transaction(kSimpleGET_Transaction);
prefetch_transaction.load_flags |= LOAD_PREFETCH;
RunTransactionTestWithResponseInfoAndGetTiming(
cache.http_cache(), prefetch_transaction, &response_info,
NetLogWithSource::Make(NetLogSourceType::NONE), nullptr);
EXPECT_TRUE(response_info.unused_since_prefetch);
EXPECT_FALSE(response_info.was_cached);
// Try to use it while injecting a failure on write.
cache.disk_cache()->set_soft_failures_mask(MockDiskEntry::FAIL_WRITE);
RunTransactionTestWithResponseInfoAndGetTiming(
cache.http_cache(), kSimpleGET_Transaction, &response_info,
NetLogWithSource::Make(NetLogSourceType::NONE), nullptr);
}
// Make sure that if a prefetch entry is truncated, then an attempt to re-use it
// gets aborted in connected handler that truncated bit is not lost.
TEST_F(HttpCacheTest, PrefetchTruncateCancelInConnectedCallback) {
MockHttpCache cache;
ScopedMockTransaction transaction(kSimpleGET_Transaction);
transaction.response_headers =
"Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
"Content-Length: 20\n"
"Etag: \"foopy\"\n";
transaction.data = "01234567890123456789";
transaction.load_flags |= LOAD_PREFETCH | LOAD_CAN_USE_RESTRICTED_PREFETCH;
// Do a truncated read of a prefetch request.
{
MockHttpRequest request(transaction);
Context c;
int rv = cache.CreateTransaction(&c.trans);
ASSERT_THAT(rv, IsOk());
rv = c.callback.GetResult(
c.trans->Start(&request, c.callback.callback(), NetLogWithSource()));
ASSERT_THAT(rv, IsOk());
// Read less than the whole thing.
scoped_refptr<IOBufferWithSize> buf =
base::MakeRefCounted<IOBufferWithSize>(10);
rv = c.callback.GetResult(
c.trans->Read(buf.get(), buf->size(), c.callback.callback()));
EXPECT_EQ(buf->size(), rv);
// Destroy the transaction.
c.trans.reset();
base::RunLoop().RunUntilIdle();
VerifyTruncatedFlag(&cache, request.CacheKey(), /*flag_value=*/true,
/*data_size=*/10);
}
// Do a fetch that can use prefetch that aborts in connected handler.
transaction.load_flags &= ~LOAD_PREFETCH;
{
MockHttpRequest request(transaction);
Context c;
int rv = cache.CreateTransaction(&c.trans);
ASSERT_THAT(rv, IsOk());
c.trans->SetConnectedCallback(base::BindRepeating(
[](const TransportInfo& info, CompletionOnceCallback callback) -> int {
return net::ERR_ABORTED;
}));
rv = c.callback.GetResult(
c.trans->Start(&request, c.callback.callback(), NetLogWithSource()));
EXPECT_EQ(net::ERR_ABORTED, rv);
// Destroy the transaction.
c.trans.reset();
base::RunLoop().RunUntilIdle();
VerifyTruncatedFlag(&cache, request.CacheKey(), /*flag_value=*/true,
/*data_size=*/10);
}
// Now try again without abort.
{
MockHttpRequest request(transaction);
RunTransactionTestWithRequest(cache.http_cache(), transaction, request,
/*response_info=*/nullptr);
base::RunLoop().RunUntilIdle();
VerifyTruncatedFlag(&cache, request.CacheKey(), /*flag_value=*/false,
/*data_size=*/20);
}
}
// Make sure that if a stale-while-revalidate entry is truncated, then an
// attempt to re-use it gets aborted in connected handler that truncated bit is
// not lost.
TEST_F(HttpCacheTest, StaleWhiteRevalidateTruncateCancelInConnectedCallback) {
MockHttpCache cache;
ScopedMockTransaction transaction(kSimpleGET_Transaction);
transaction.response_headers =
"Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
"Content-Length: 20\n"
"Cache-Control: max-age=0, stale-while-revalidate=60\n"
"Etag: \"foopy\"\n";
transaction.data = "01234567890123456789";
transaction.load_flags |= LOAD_SUPPORT_ASYNC_REVALIDATION;
// Do a truncated read of a stale-while-revalidate resource.
{
MockHttpRequest request(transaction);
Context c;
int rv = cache.CreateTransaction(&c.trans);
ASSERT_THAT(rv, IsOk());
rv = c.callback.GetResult(
c.trans->Start(&request, c.callback.callback(), NetLogWithSource()));
ASSERT_THAT(rv, IsOk());
// Read less than the whole thing.
scoped_refptr<IOBufferWithSize> buf =
base::MakeRefCounted<IOBufferWithSize>(10);
rv = c.callback.GetResult(
c.trans->Read(buf.get(), buf->size(), c.callback.callback()));
EXPECT_EQ(buf->size(), rv);
// Destroy the transaction.
c.trans.reset();
base::RunLoop().RunUntilIdle();
VerifyTruncatedFlag(&cache, request.CacheKey(), /*flag_value=*/true,
/*data_size=*/10);
}
// Do a fetch that uses that resource that aborts in connected handler.
{
MockHttpRequest request(transaction);
Context c;
int rv = cache.CreateTransaction(&c.trans);
ASSERT_THAT(rv, IsOk());
c.trans->SetConnectedCallback(base::BindRepeating(
[](const TransportInfo& info, CompletionOnceCallback callback) -> int {
return net::ERR_ABORTED;
}));
rv = c.callback.GetResult(
c.trans->Start(&request, c.callback.callback(), NetLogWithSource()));
EXPECT_EQ(net::ERR_ABORTED, rv);
// Destroy the transaction.
c.trans.reset();
base::RunLoop().RunUntilIdle();
VerifyTruncatedFlag(&cache, request.CacheKey(), /*flag_value=*/true,
/*data_size=*/10);
}
// Now try again without abort.
{
MockHttpRequest request(transaction);
RunTransactionTestWithRequest(cache.http_cache(), transaction, request,
/*response_info=*/nullptr);
base::RunLoop().RunUntilIdle();
VerifyTruncatedFlag(&cache, request.CacheKey(), /*flag_value=*/false,
/*data_size=*/20);
}
}
static void PreserveRequestHeaders_Handler(const HttpRequestInfo* request,
std::string* response_status,
std::string* response_headers,
std::string* response_data) {
EXPECT_TRUE(request->extra_headers.HasHeader(kExtraHeaderKey));
}
// Tests that we don't remove extra headers for simple requests.
TEST_F(HttpCacheTest, SimpleGET_PreserveRequestHeaders) {
for (bool use_memory_entry_data : {false, true}) {
MockHttpCache cache;
cache.disk_cache()->set_support_in_memory_entry_data(use_memory_entry_data);
MockTransaction transaction(kSimpleGET_Transaction);
transaction.handler = PreserveRequestHeaders_Handler;
transaction.request_headers = EXTRA_HEADER;
transaction.response_headers = "Cache-Control: max-age=0\n";
AddMockTransaction(&transaction);
// Write, then revalidate the entry.
RunTransactionTest(cache.http_cache(), transaction);
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
// If the backend supports memory entry data, we can figure out that the
// entry has caching-hostile headers w/o opening it.
if (use_memory_entry_data) {
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
} else {
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
RemoveMockTransaction(&transaction);
}
}
// Tests that we don't remove extra headers for conditionalized requests.
TEST_F(HttpCacheTest, ConditionalizedGET_PreserveRequestHeaders) {
for (bool use_memory_entry_data : {false, true}) {
MockHttpCache cache;
// Unlike in SimpleGET_PreserveRequestHeaders, this entry can be
// conditionalized, so memory hints don't affect behavior.
cache.disk_cache()->set_support_in_memory_entry_data(use_memory_entry_data);
// Write to the cache.
RunTransactionTest(cache.http_cache(), kETagGET_Transaction);
MockTransaction transaction(kETagGET_Transaction);
transaction.handler = PreserveRequestHeaders_Handler;
transaction.request_headers = "If-None-Match: \"foopy\"\r\n" EXTRA_HEADER;
AddMockTransaction(&transaction);
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
}
TEST_F(HttpCacheTest, SimpleGET_ManyReaders) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 5;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
auto& c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
c->result =
c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
}
// All requests are waiting for the active entry.
for (auto& context : context_list) {
EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE, context->trans->GetLoadState());
}
// Allow all requests to move from the Create queue to the active entry.
base::RunLoop().RunUntilIdle();
// All requests are added to writers.
std::string cache_key = request.CacheKey();
EXPECT_EQ(kNumTransactions, cache.GetCountWriterTransactions(cache_key));
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// All requests are between Start and Read, i.e. idle.
for (auto& context : context_list) {
EXPECT_EQ(LOAD_STATE_IDLE, context->trans->GetLoadState());
}
for (int i = 0; i < kNumTransactions; ++i) {
auto& c = context_list[i];
if (c->result == ERR_IO_PENDING)
c->result = c->callback.WaitForResult();
// After the 1st transaction has completed the response, all transactions
// get added to readers.
if (i > 0) {
EXPECT_FALSE(cache.IsWriterPresent(cache_key));
EXPECT_EQ(kNumTransactions - i, cache.GetCountReaders(cache_key));
}
ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
}
// We should not have had to re-open the disk entry
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
TEST_F(HttpCacheTest, RangeGET_FullAfterPartial) {
MockHttpCache cache;
// Request a prefix.
{
ScopedMockTransaction transaction_pre(kRangeGET_TransactionOK);
transaction_pre.request_headers = "Range: bytes = 0-9\r\n" EXTRA_HEADER;
transaction_pre.data = "rg: 00-09 ";
MockHttpRequest request_pre(transaction_pre);
HttpResponseInfo response_pre;
RunTransactionTestWithRequest(cache.http_cache(), transaction_pre,
request_pre, &response_pre);
ASSERT_TRUE(response_pre.headers != nullptr);
EXPECT_EQ(206, response_pre.headers->response_code());
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
{
// Now request the full thing, but set validation to fail. This would
// previously fail in the middle of data and truncate it; current behavior
// restarts it, somewhat wastefully but gets the data back.
RangeTransactionServer handler;
handler.set_modified(true);
ScopedMockTransaction transaction_all(kRangeGET_TransactionOK);
transaction_all.request_headers = EXTRA_HEADER;
transaction_all.data = "Not a range";
MockHttpRequest request_all(transaction_all);
HttpResponseInfo response_all;
RunTransactionTestWithRequest(cache.http_cache(), transaction_all,
request_all, &response_all);
ASSERT_TRUE(response_all.headers != nullptr);
EXPECT_EQ(200, response_all.headers->response_code());
// 1 from previous test, failed validation, and re-try.
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
}
// Tests that when a range request transaction becomes a writer for the first
// range and then fails conditionalization for the next range and decides to
// doom the entry, then there should not be a dcheck assertion hit.
TEST_F(HttpCacheTest, RangeGET_OverlappingRangesCouldntConditionalize) {
MockHttpCache cache;
{
ScopedMockTransaction transaction_pre(kRangeGET_TransactionOK);
transaction_pre.request_headers = "Range: bytes = 10-19\r\n" EXTRA_HEADER;
transaction_pre.data = "rg: 10-19 ";
MockHttpRequest request_pre(transaction_pre);
HttpResponseInfo response_pre;
RunTransactionTestWithRequest(cache.http_cache(), transaction_pre,
request_pre, &response_pre);
ASSERT_TRUE(response_pre.headers != nullptr);
EXPECT_EQ(206, response_pre.headers->response_code());
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
{
// First range skips validation because the response is fresh while the
// second range requires validation since that range is not present in the
// cache and during validation it fails conditionalization.
cache.FailConditionalizations();
ScopedMockTransaction transaction_pre(kRangeGET_TransactionOK);
transaction_pre.request_headers = "Range: bytes = 10-29\r\n" EXTRA_HEADER;
// TODO(crbug.com/992521): Fix this scenario to not return the cached bytes
// repeatedly.
transaction_pre.data = "rg: 10-19 rg: 10-19 rg: 20-29 ";
MockHttpRequest request_pre(transaction_pre);
HttpResponseInfo response_pre;
RunTransactionTestWithRequest(cache.http_cache(), transaction_pre,
request_pre, &response_pre);
ASSERT_TRUE(response_pre.headers != nullptr);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
}
TEST_F(HttpCacheTest, RangeGET_FullAfterPartialReuse) {
MockHttpCache cache;
// Request a prefix.
{
ScopedMockTransaction transaction_pre(kRangeGET_TransactionOK);
transaction_pre.request_headers = "Range: bytes = 0-9\r\n" EXTRA_HEADER;
transaction_pre.data = "rg: 00-09 ";
MockHttpRequest request_pre(transaction_pre);
HttpResponseInfo response_pre;
RunTransactionTestWithRequest(cache.http_cache(), transaction_pre,
request_pre, &response_pre);
ASSERT_TRUE(response_pre.headers != nullptr);
EXPECT_EQ(206, response_pre.headers->response_code());
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
{
// Now request the full thing, revalidating successfully, so the full
// file gets stored via a sparse-entry.
ScopedMockTransaction transaction_all(kRangeGET_TransactionOK);
transaction_all.request_headers = EXTRA_HEADER;
transaction_all.data =
"rg: 00-09 rg: 10-19 rg: 20-29 rg: 30-39 rg: 40-49"
" rg: 50-59 rg: 60-69 rg: 70-79 ";
MockHttpRequest request_all(transaction_all);
HttpResponseInfo response_all;
RunTransactionTestWithRequest(cache.http_cache(), transaction_all,
request_all, &response_all);
ASSERT_TRUE(response_all.headers != nullptr);
EXPECT_EQ(200, response_all.headers->response_code());
// 1 from previous test, validation, and second chunk
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
{
// Grab it again, should not need re-validation.
ScopedMockTransaction transaction_all2(kRangeGET_TransactionOK);
transaction_all2.request_headers = EXTRA_HEADER;
transaction_all2.data =
"rg: 00-09 rg: 10-19 rg: 20-29 rg: 30-39 rg: 40-49"
" rg: 50-59 rg: 60-69 rg: 70-79 ";
MockHttpRequest request_all2(transaction_all2);
HttpResponseInfo response_all2;
RunTransactionTestWithRequest(cache.http_cache(), transaction_all2,
request_all2, &response_all2);
ASSERT_TRUE(response_all2.headers != nullptr);
EXPECT_EQ(200, response_all2.headers->response_code());
// Only one more cache open, no new network traffic.
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(2, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
}
// This test verifies that the ConnectedCallback passed to a cache transaction
// is called once per subrange in the case of a range request with a partial
// cache hit.
TEST_F(HttpCacheTest, RangeGET_ConnectedCallbackCalledForEachRange) {
MockHttpCache cache;
// Request an infix range and populate the cache with it.
{
ScopedMockTransaction mock_transaction(kRangeGET_TransactionOK);
mock_transaction.request_headers = "Range: bytes = 20-29\r\n" EXTRA_HEADER;
mock_transaction.data = "rg: 20-29 ";
mock_transaction.transport_info = TestTransportInfo();
RunTransactionTest(cache.http_cache(), mock_transaction);
}
// Request a surrounding range and observe that the callback is called once
// per subrange, as split up by cache hits.
{
ScopedMockTransaction mock_transaction(kRangeGET_TransactionOK);
mock_transaction.request_headers = "Range: bytes = 10-39\r\n" EXTRA_HEADER;
mock_transaction.data = "rg: 10-19 rg: 20-29 rg: 30-39 ";
mock_transaction.transport_info = TestTransportInfo();
MockHttpRequest request(mock_transaction);
ConnectedHandler connected_handler;
std::unique_ptr<HttpTransaction> transaction;
EXPECT_THAT(cache.CreateTransaction(&transaction), IsOk());
ASSERT_THAT(transaction, NotNull());
transaction->SetConnectedCallback(connected_handler.Callback());
TestCompletionCallback callback;
ASSERT_THAT(
transaction->Start(&request, callback.callback(), NetLogWithSource()),
IsError(ERR_IO_PENDING));
EXPECT_THAT(callback.WaitForResult(), IsOk());
// 1 call for the first range's network transaction.
EXPECT_THAT(connected_handler.transports(),
ElementsAre(TestTransportInfo()));
// Switch the endpoint for the next network transaction to observe.
// For ease, we just switch the port number.
//
// NOTE: This works because only the mock transaction struct's address is
// registered with the mocking framework - the pointee data is consulted
// each time it is read.
mock_transaction.transport_info = TestTransportInfoWithPort(123);
ReadAndVerifyTransaction(transaction.get(), mock_transaction);
// A second call for the cached range, reported as coming from the original
// endpoint it was cached from. A third call for the last range's network
// transaction.
EXPECT_THAT(connected_handler.transports(),
ElementsAre(TestTransportInfo(), CachedTestTransportInfo(),
TestTransportInfoWithPort(123)));
}
}
// This test verifies that when the ConnectedCallback passed to a cache range
// transaction returns an `ERR_INCONSISTENT_IP_ADDRESS_SPACE` error during a
// partial read from cache, then the cache entry is invalidated.
TEST_F(HttpCacheTest, RangeGET_ConnectedCallbackReturnInconsistentIpError) {
MockHttpCache cache;
// Request an infix range and populate the cache with it.
{
ScopedMockTransaction mock_transaction(kRangeGET_TransactionOK);
mock_transaction.request_headers = "Range: bytes = 20-29\r\n" EXTRA_HEADER;
mock_transaction.data = "rg: 20-29 ";
mock_transaction.transport_info = TestTransportInfo();
RunTransactionTest(cache.http_cache(), mock_transaction);
}
ScopedMockTransaction mock_transaction(kRangeGET_TransactionOK);
mock_transaction.request_headers = "Range: bytes = 10-39\r\n" EXTRA_HEADER;
mock_transaction.data = "rg: 10-19 rg: 20-29 rg: 30-39 ";
mock_transaction.transport_info = TestTransportInfo();
MockHttpRequest request(mock_transaction);
// Request a surrounding range. This *should* be read in three parts:
//
// 1. for the prefix: from the network
// 2. for the cached infix: from the cache
// 3. for the suffix: from the network
//
// The connected callback returns OK for 1), but fails during 2). As a result,
// the transaction fails partway and 3) is never created. The cache entry is
// invalidated as a result of the specific error code.
{
ConnectedHandler connected_handler;
std::unique_ptr<HttpTransaction> transaction;
EXPECT_THAT(cache.CreateTransaction(&transaction), IsOk());
ASSERT_THAT(transaction, NotNull());
transaction->SetConnectedCallback(connected_handler.Callback());
TestCompletionCallback callback;
ASSERT_THAT(
transaction->Start(&request, callback.callback(), NetLogWithSource()),
IsError(ERR_IO_PENDING));
EXPECT_THAT(callback.WaitForResult(), IsOk());
// 1 call for the first range's network transaction.
EXPECT_THAT(connected_handler.transports(),
ElementsAre(TestTransportInfo()));
// Set the callback to return an error the next time it is called.
connected_handler.set_result(ERR_INCONSISTENT_IP_ADDRESS_SPACE);
std::string content;
EXPECT_THAT(ReadTransaction(transaction.get(), &content),
IsError(ERR_INCONSISTENT_IP_ADDRESS_SPACE));
// A second call that failed.
EXPECT_THAT(connected_handler.transports(),
ElementsAre(TestTransportInfo(), CachedTestTransportInfo()));
}
// Request the same range again, observe that nothing is read from cache.
{
ConnectedHandler connected_handler;
std::unique_ptr<HttpTransaction> transaction;
EXPECT_THAT(cache.CreateTransaction(&transaction), IsOk());
ASSERT_THAT(transaction, NotNull());
transaction->SetConnectedCallback(connected_handler.Callback());
TestCompletionCallback callback;
ASSERT_THAT(
transaction->Start(&request, callback.callback(), NetLogWithSource()),
IsError(ERR_IO_PENDING));
EXPECT_THAT(callback.WaitForResult(), IsOk());
std::string content;
EXPECT_THAT(ReadTransaction(transaction.get(), &content), IsOk());
EXPECT_EQ(content, mock_transaction.data);
// 1 call for the network transaction from which the whole response was
// read. The first 20 bytes were cached by the previous two requests, but
// the cache entry was doomed during the last transaction so they are not
// used here.
EXPECT_THAT(connected_handler.transports(),
ElementsAre(TestTransportInfo()));
}
}
// This test verifies that when the ConnectedCallback passed to a cache range
// transaction returns an `ERR_INCONSISTENT_IP_ADDRESS_SPACE` error during a
// network transaction, then the cache entry is invalidated.
TEST_F(HttpCacheTest,
RangeGET_ConnectedCallbackReturnInconsistentIpErrorForNetwork) {
MockHttpCache cache;
// Request a prefix range and populate the cache with it.
{
ScopedMockTransaction mock_transaction(kRangeGET_TransactionOK);
mock_transaction.request_headers = "Range: bytes = 10-19\r\n" EXTRA_HEADER;
mock_transaction.data = "rg: 10-19 ";
mock_transaction.transport_info = TestTransportInfo();
RunTransactionTest(cache.http_cache(), mock_transaction);
}
ScopedMockTransaction mock_transaction(kRangeGET_TransactionOK);
mock_transaction.request_headers = "Range: bytes = 10-29\r\n" EXTRA_HEADER;
mock_transaction.data = "rg: 10-19 rg: 20-29 ";
mock_transaction.transport_info = TestTransportInfo();
MockHttpRequest request(mock_transaction);
// Request a longer range. This *should* be read in two parts:
//
// 1. for the prefix: from the cache
// 2. for the suffix: from the network
{
ConnectedHandler connected_handler;
std::unique_ptr<HttpTransaction> transaction;
EXPECT_THAT(cache.CreateTransaction(&transaction), IsOk());
ASSERT_THAT(transaction, NotNull());
transaction->SetConnectedCallback(connected_handler.Callback());
TestCompletionCallback callback;
ASSERT_THAT(
transaction->Start(&request, callback.callback(), NetLogWithSource()),
IsError(ERR_IO_PENDING));
EXPECT_THAT(callback.WaitForResult(), IsOk());
// 1 call for the first range's network transaction.
EXPECT_THAT(connected_handler.transports(),
ElementsAre(CachedTestTransportInfo()));
// Set the callback to return an error the next time it is called.
connected_handler.set_result(ERR_INCONSISTENT_IP_ADDRESS_SPACE);
std::string content;
EXPECT_THAT(ReadTransaction(transaction.get(), &content),
IsError(ERR_INCONSISTENT_IP_ADDRESS_SPACE));
// A second call that failed.
EXPECT_THAT(connected_handler.transports(),
ElementsAre(CachedTestTransportInfo(), TestTransportInfo()));
}
// Request the same range again, observe that nothing is read from cache.
{
ConnectedHandler connected_handler;
std::unique_ptr<HttpTransaction> transaction;
EXPECT_THAT(cache.CreateTransaction(&transaction), IsOk());
ASSERT_THAT(transaction, NotNull());
transaction->SetConnectedCallback(connected_handler.Callback());
TestCompletionCallback callback;
ASSERT_THAT(
transaction->Start(&request, callback.callback(), NetLogWithSource()),
IsError(ERR_IO_PENDING));
EXPECT_THAT(callback.WaitForResult(), IsOk());
std::string content;
EXPECT_THAT(ReadTransaction(transaction.get(), &content), IsOk());
EXPECT_EQ(content, mock_transaction.data);
// 1 call for the network transaction from which the whole response was
// read. The first 20 bytes were cached by the previous two requests, but
// the cache entry was doomed during the last transaction so they are not
// used here.
EXPECT_THAT(connected_handler.transports(),
ElementsAre(TestTransportInfo()));
}
}
// This test verifies that when the ConnectedCallback passed to a cache
// transaction returns an error for the second (or third) subrange transaction,
// the overall cache transaction fails with that error. The cache entry is still
// usable after that.
TEST_F(HttpCacheTest, RangeGET_ConnectedCallbackReturnErrorSecondTime) {
MockHttpCache cache;
// Request an infix range and populate the cache with it.
{
ScopedMockTransaction mock_transaction(kRangeGET_TransactionOK);
mock_transaction.request_headers = "Range: bytes = 20-29\r\n" EXTRA_HEADER;
mock_transaction.data = "rg: 20-29 ";
mock_transaction.transport_info = TestTransportInfo();
RunTransactionTest(cache.http_cache(), mock_transaction);
}
ScopedMockTransaction mock_transaction(kRangeGET_TransactionOK);
mock_transaction.request_headers = "Range: bytes = 10-39\r\n" EXTRA_HEADER;
mock_transaction.data = "rg: 10-19 rg: 20-29 rg: 30-39 ";
mock_transaction.transport_info = TestTransportInfo();
MockHttpRequest request(mock_transaction);
// Request a surrounding range. This *should* be read in three parts:
//
// 1. for the prefix: from the network
// 2. for the cached infix: from the cache
// 3. for the suffix: from the network
//
// The connected callback returns OK for 1), but fails during 2). As a result,
// the transaction fails partway and 3) is never created. The prefix is still
// cached, such that the cache entry ends up with both the prefix and infix.
{
ConnectedHandler connected_handler;
std::unique_ptr<HttpTransaction> transaction;
EXPECT_THAT(cache.CreateTransaction(&transaction), IsOk());
ASSERT_THAT(transaction, NotNull());
transaction->SetConnectedCallback(connected_handler.Callback());
TestCompletionCallback callback;
ASSERT_THAT(
transaction->Start(&request, callback.callback(), NetLogWithSource()),
IsError(ERR_IO_PENDING));
EXPECT_THAT(callback.WaitForResult(), IsOk());
// 1 call for the first range's network transaction.
EXPECT_THAT(connected_handler.transports(),
ElementsAre(TestTransportInfo()));
// Set the callback to return an error the next time it is called. The exact
// error code is irrelevant, what matters is that it is reflected in the
// overall status of the transaction.
connected_handler.set_result(ERR_NOT_IMPLEMENTED);
std::string content;
EXPECT_THAT(ReadTransaction(transaction.get(), &content),
IsError(ERR_NOT_IMPLEMENTED));
// A second call that failed.
EXPECT_THAT(connected_handler.transports(),
ElementsAre(TestTransportInfo(), CachedTestTransportInfo()));
}
// Request the same range again, observe that the prefix and infix are both
// read from cache. Only the suffix is fetched from the network.
{
ConnectedHandler connected_handler;
std::unique_ptr<HttpTransaction> transaction;
EXPECT_THAT(cache.CreateTransaction(&transaction), IsOk());
ASSERT_THAT(transaction, NotNull());
transaction->SetConnectedCallback(connected_handler.Callback());
TestCompletionCallback callback;
ASSERT_THAT(
transaction->Start(&request, callback.callback(), NetLogWithSource()),
IsError(ERR_IO_PENDING));
EXPECT_THAT(callback.WaitForResult(), IsOk());
// 1 call for the first range's cache transaction: the first 20 bytes were
// cached by the previous two requests.
EXPECT_THAT(connected_handler.transports(),
ElementsAre(CachedTestTransportInfo()));
std::string content;
EXPECT_THAT(ReadTransaction(transaction.get(), &content), IsOk());
EXPECT_EQ(content, mock_transaction.data);
// A second call from the network transaction for the last 10 bytes.
EXPECT_THAT(connected_handler.transports(),
ElementsAre(CachedTestTransportInfo(), TestTransportInfo()));
}
}
// This test verifies that the ConnectedCallback passed to a cache transaction
// is called once per subrange in the case of a range request with a partial
// cache hit, even when a prefix of the range is cached.
TEST_F(HttpCacheTest, RangeGET_ConnectedCallbackCalledForEachRangeWithPrefix) {
MockHttpCache cache;
// Request a prefix range and populate the cache with it.
{
ScopedMockTransaction mock_transaction(kRangeGET_TransactionOK);
mock_transaction.request_headers = "Range: bytes = 10-19\r\n" EXTRA_HEADER;
mock_transaction.data = "rg: 10-19 ";
mock_transaction.transport_info = TestTransportInfo();
RunTransactionTest(cache.http_cache(), mock_transaction);
}
// Request a surrounding range and observe that the callback is called once
// per subrange, as split up by cache hits.
{
ScopedMockTransaction mock_transaction(kRangeGET_TransactionOK);
mock_transaction.request_headers = "Range: bytes = 10-39\r\n" EXTRA_HEADER;
mock_transaction.data = "rg: 10-19 rg: 20-29 rg: 30-39 ";
mock_transaction.transport_info = TestTransportInfoWithPort(123);
MockHttpRequest request(mock_transaction);
ConnectedHandler connected_handler;
std::unique_ptr<HttpTransaction> transaction;
EXPECT_THAT(cache.CreateTransaction(&transaction), IsOk());
ASSERT_THAT(transaction, NotNull());
transaction->SetConnectedCallback(connected_handler.Callback());
TestCompletionCallback callback;
ASSERT_THAT(
transaction->Start(&request, callback.callback(), NetLogWithSource()),
IsError(ERR_IO_PENDING));
EXPECT_THAT(callback.WaitForResult(), IsOk());
// 1 call for the first range from the cache, reported as coming from the
// endpoint which initially served the cached range.
EXPECT_THAT(connected_handler.transports(),
ElementsAre(CachedTestTransportInfo()));
ReadAndVerifyTransaction(transaction.get(), mock_transaction);
// A second call for the last range's network transaction.
EXPECT_THAT(
connected_handler.transports(),
ElementsAre(CachedTestTransportInfo(), TestTransportInfoWithPort(123)));
}
}
// Tests that a range transaction is still usable even if it's unable to access
// the cache.
TEST_F(HttpCacheTest, RangeGET_FailedCacheAccess) {
MockHttpCache cache;
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
MockHttpRequest request(transaction);
auto c = std::make_unique<Context>();
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
cache.disk_cache()->set_fail_requests(true);
c->result =
c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(cache.IsWriterPresent(kRangeGET_TransactionOK.url));
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(0, cache.disk_cache()->create_count());
c->result = c->callback.WaitForResult();
ReadAndVerifyTransaction(c->trans.get(), kRangeGET_TransactionOK);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(0, cache.disk_cache()->create_count());
}
// Tests that we can have parallel validation on range requests.
TEST_F(HttpCacheTest, RangeGET_ParallelValidationNoMatch) {
MockHttpCache cache;
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
MockHttpRequest request(transaction);
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 5;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
auto& c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
c->result =
c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
}
// All requests are waiting for the active entry.
for (auto& context : context_list) {
EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE, context->trans->GetLoadState());
}
// Allow all requests to move from the Create queue to the active entry.
base::RunLoop().RunUntilIdle();
// First entry created is doomed due to 2nd transaction's validation leading
// to restarting of the queued transactions.
EXPECT_TRUE(cache.IsWriterPresent(request.CacheKey()));
// TODO(shivanisha): The restarted transactions race for creating the entry
// and thus instead of all 4 succeeding, 2 of them succeed. This is very
// implementation specific and happens because the queued transactions get
// restarted synchronously and get to the queue of creating the entry before
// the transaction that is restarting them. Fix the test to make it less
// vulnerable to any scheduling changes in the code.
EXPECT_EQ(5, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(3, cache.disk_cache()->create_count());
for (auto& context : context_list) {
EXPECT_EQ(LOAD_STATE_IDLE, context->trans->GetLoadState());
}
for (int i = 0; i < kNumTransactions; ++i) {
auto& c = context_list[i];
if (c->result == ERR_IO_PENDING)
c->result = c->callback.WaitForResult();
ReadAndVerifyTransaction(c->trans.get(), kRangeGET_TransactionOK);
}
EXPECT_EQ(5, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(3, cache.disk_cache()->create_count());
}
// Tests that if a transaction is dooming the entry and the entry was doomed by
// another transaction that was not part of the entry and created a new entry,
// the new entry should not be incorrectly doomed. (crbug.com/736993)
TEST_F(HttpCacheTest, RangeGET_ParallelValidationNoMatchDoomEntry) {
MockHttpCache cache;
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
MockHttpRequest request(transaction);
MockTransaction dooming_transaction(kRangeGET_TransactionOK);
dooming_transaction.load_flags |= LOAD_BYPASS_CACHE;
MockHttpRequest dooming_request(dooming_transaction);
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 3;
scoped_refptr<MockDiskEntry> first_entry;
scoped_refptr<MockDiskEntry> second_entry;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
auto& c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
MockHttpRequest* this_request = &request;
if (i == 2)
this_request = &dooming_request;
if (i == 1) {
ASSERT_TRUE(first_entry);
first_entry->SetDefer(MockDiskEntry::DEFER_READ);
}
c->result = c->trans->Start(this_request, c->callback.callback(),
NetLogWithSource());
// Continue the transactions. 2nd will pause at the cache reading state and
// 3rd transaction will doom the entry.
base::RunLoop().RunUntilIdle();
std::string cache_key = request.CacheKey();
// Check status of the first and second entries after every transaction.
switch (i) {
case 0:
first_entry = cache.disk_cache()->GetDiskEntryRef(cache_key);
break;
case 1:
EXPECT_FALSE(first_entry->is_doomed());
break;
case 2:
EXPECT_TRUE(first_entry->is_doomed());
second_entry = cache.disk_cache()->GetDiskEntryRef(cache_key);
EXPECT_FALSE(second_entry->is_doomed());
break;
}
}
// Resume cache read by 1st transaction which will lead to dooming the entry
// as well since the entry cannot be validated. This double dooming should not
// lead to an assertion.
first_entry->ResumeDiskEntryOperation();
base::RunLoop().RunUntilIdle();
// Since second_entry is already created, when 1st transaction goes on to
// create an entry, it will get ERR_CACHE_RACE leading to dooming of
// second_entry and creation of a third entry.
EXPECT_TRUE(second_entry->is_doomed());
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(3, cache.disk_cache()->create_count());
for (auto& context : context_list) {
EXPECT_EQ(LOAD_STATE_IDLE, context->trans->GetLoadState());
}
for (auto& c : context_list) {
ReadAndVerifyTransaction(c->trans.get(), kRangeGET_TransactionOK);
}
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(3, cache.disk_cache()->create_count());
}
// Same as above but tests that the 2nd transaction does not do anything if
// there is nothing to doom. (crbug.com/736993)
TEST_F(HttpCacheTest, RangeGET_ParallelValidationNoMatchDoomEntry1) {
MockHttpCache cache;
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
MockHttpRequest request(transaction);
MockTransaction dooming_transaction(kRangeGET_TransactionOK);
dooming_transaction.load_flags |= LOAD_BYPASS_CACHE;
MockHttpRequest dooming_request(dooming_transaction);
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 3;
scoped_refptr<MockDiskEntry> first_entry;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
auto& c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
MockHttpRequest* this_request = &request;
if (i == 2) {
this_request = &dooming_request;
cache.disk_cache()->SetDefer(MockDiskEntry::DEFER_CREATE);
}
if (i == 1) {
ASSERT_TRUE(first_entry);
first_entry->SetDefer(MockDiskEntry::DEFER_READ);
}
c->result = c->trans->Start(this_request, c->callback.callback(),
NetLogWithSource());
// Continue the transactions. 2nd will pause at the cache reading state and
// 3rd transaction will doom the entry and pause before creating a new
// entry.
base::RunLoop().RunUntilIdle();
// Check status of the entry after every transaction.
switch (i) {
case 0:
first_entry = cache.disk_cache()->GetDiskEntryRef(request.CacheKey());
break;
case 1:
EXPECT_FALSE(first_entry->is_doomed());
break;
case 2:
EXPECT_TRUE(first_entry->is_doomed());
break;
}
}
// Resume cache read by 2nd transaction which will lead to dooming the entry
// as well since the entry cannot be validated. This double dooming should not
// lead to an assertion.
first_entry->ResumeDiskEntryOperation();
base::RunLoop().RunUntilIdle();
// Resume creation of entry by 3rd transaction.
cache.disk_cache()->ResumeCacheOperation();
base::RunLoop().RunUntilIdle();
// Note that since 3rd transaction's entry is already created but its
// callback is deferred, MockDiskCache's implementation returns
// ERR_CACHE_CREATE_FAILURE when 2nd transaction tries to create an entry
// during that time, leading to it switching over to pass-through mode.
// Thus the number of entries is 2 below.
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
for (auto& context : context_list) {
EXPECT_EQ(LOAD_STATE_IDLE, context->trans->GetLoadState());
}
for (auto& c : context_list) {
ReadAndVerifyTransaction(c->trans.get(), kRangeGET_TransactionOK);
}
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests parallel validation on range requests with non-overlapping ranges.
TEST_F(HttpCacheTest, RangeGET_ParallelValidationDifferentRanges) {
MockHttpCache cache;
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 2;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
}
// Let 1st transaction complete headers phase for ranges 40-49.
std::string first_read;
MockHttpRequest request1(transaction);
{
auto& c = context_list[0];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
c->result =
c->trans->Start(&request1, c->callback.callback(), NetLogWithSource());
base::RunLoop().RunUntilIdle();
// Start writing to the cache so that MockDiskEntry::CouldBeSparse() returns
// true.
const int kBufferSize = 5;
scoped_refptr<IOBuffer> buffer =
base::MakeRefCounted<IOBuffer>(kBufferSize);
ReleaseBufferCompletionCallback cb(buffer.get());
c->result = c->trans->Read(buffer.get(), kBufferSize, cb.callback());
EXPECT_EQ(kBufferSize, cb.GetResult(c->result));
std::string data_read(buffer->data(), kBufferSize);
first_read = data_read;
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
}
// 2nd transaction requests ranges 30-39.
transaction.request_headers = "Range: bytes = 30-39\r\n" EXTRA_HEADER;
MockHttpRequest request2(transaction);
{
auto& c = context_list[1];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
c->result =
c->trans->Start(&request2, c->callback.callback(), NetLogWithSource());
base::RunLoop().RunUntilIdle();
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
}
std::string cache_key = request2.CacheKey();
EXPECT_TRUE(cache.IsWriterPresent(cache_key));
EXPECT_EQ(1, cache.GetCountDoneHeadersQueue(cache_key));
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
for (int i = 0; i < kNumTransactions; ++i) {
auto& c = context_list[i];
if (c->result == ERR_IO_PENDING)
c->result = c->callback.WaitForResult();
if (i == 0) {
ReadRemainingAndVerifyTransaction(c->trans.get(), first_read,
transaction);
continue;
}
transaction.data = "rg: 30-39 ";
ReadAndVerifyTransaction(c->trans.get(), transaction);
}
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Fetch from the cache to check that ranges 30-49 have been successfully
// cached.
{
MockTransaction range_transaction(kRangeGET_TransactionOK);
range_transaction.request_headers = "Range: bytes = 30-49\r\n" EXTRA_HEADER;
range_transaction.data = "rg: 30-39 rg: 40-49 ";
std::string headers;
RunTransactionTestWithResponse(cache.http_cache(), range_transaction,
&headers);
Verify206Response(headers, 30, 49);
}
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
context_list.clear();
}
// Tests that a request does not create Writers when readers is not empty.
TEST_F(HttpCacheTest, RangeGET_DoNotCreateWritersWhenReaderExists) {
MockHttpCache cache;
// Save a request in the cache so that the next request can become a
// reader.
MockTransaction transaction(kRangeGET_Transaction);
transaction.request_headers = EXTRA_HEADER;
AddMockTransaction(&transaction);
RunTransactionTest(cache.http_cache(), transaction);
// Let this request be a reader since it doesn't need validation as per its
// load flag.
transaction.load_flags |= LOAD_SKIP_CACHE_VALIDATION;
MockHttpRequest request(transaction);
Context context;
context.result = cache.CreateTransaction(&context.trans);
ASSERT_THAT(context.result, IsOk());
context.result = context.trans->Start(&request, context.callback.callback(),
NetLogWithSource());
base::RunLoop().RunUntilIdle();
std::string cache_key = request.CacheKey();
EXPECT_EQ(1, cache.GetCountReaders(cache_key));
RemoveMockTransaction(&transaction);
// A range request should now "not" create Writers while readers is still
// non-empty.
MockTransaction range_transaction(kRangeGET_Transaction);
range_transaction.request_headers = "Range: bytes = 0-9\r\n" EXTRA_HEADER;
AddMockTransaction(&range_transaction);
MockHttpRequest range_request(range_transaction);
Context range_context;
range_context.result = cache.CreateTransaction(&range_context.trans);
ASSERT_THAT(range_context.result, IsOk());
range_context.result = range_context.trans->Start(
&range_request, range_context.callback.callback(), NetLogWithSource());
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1, cache.GetCountReaders(cache_key));
EXPECT_FALSE(cache.IsWriterPresent(cache_key));
EXPECT_EQ(1, cache.GetCountDoneHeadersQueue(cache_key));
RemoveMockTransaction(&range_transaction);
}
// Tests parallel validation on range requests can be successfully restarted
// when there is a cache lock timeout.
TEST_F(HttpCacheTest, RangeGET_ParallelValidationCacheLockTimeout) {
MockHttpCache cache;
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 2;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
}
// Let 1st transaction complete headers phase for ranges 40-49.
std::string first_read;
MockHttpRequest request1(transaction);
{
auto& c = context_list[0];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
c->result =
c->trans->Start(&request1, c->callback.callback(), NetLogWithSource());
base::RunLoop().RunUntilIdle();
// Start writing to the cache so that MockDiskEntry::CouldBeSparse() returns
// true.
const int kBufferSize = 5;
scoped_refptr<IOBuffer> buffer =
base::MakeRefCounted<IOBuffer>(kBufferSize);
ReleaseBufferCompletionCallback cb(buffer.get());
c->result = c->trans->Read(buffer.get(), kBufferSize, cb.callback());
EXPECT_EQ(kBufferSize, cb.GetResult(c->result));
std::string data_read(buffer->data(), kBufferSize);
first_read = data_read;
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
}
// Cache lock timeout will lead to dooming the entry since the transaction may
// have already written the headers.
cache.SimulateCacheLockTimeoutAfterHeaders();
// 2nd transaction requests ranges 30-39.
transaction.request_headers = "Range: bytes = 30-39\r\n" EXTRA_HEADER;
MockHttpRequest request2(transaction);
{
auto& c = context_list[1];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
c->result =
c->trans->Start(&request2, c->callback.callback(), NetLogWithSource());
base::RunLoop().RunUntilIdle();
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
}
EXPECT_EQ(0, cache.GetCountDoneHeadersQueue(request1.CacheKey()));
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
for (int i = 0; i < kNumTransactions; ++i) {
auto& c = context_list[i];
if (c->result == ERR_IO_PENDING)
c->result = c->callback.WaitForResult();
if (i == 0) {
ReadRemainingAndVerifyTransaction(c->trans.get(), first_read,
transaction);
continue;
}
transaction.data = "rg: 30-39 ";
ReadAndVerifyTransaction(c->trans.get(), transaction);
}
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Tests a full request and a simultaneous range request and the range request
// dooms the entry created by the full request due to not being able to
// conditionalize.
TEST_F(HttpCacheTest, RangeGET_ParallelValidationCouldntConditionalize) {
MockHttpCache cache;
MockTransaction mock_transaction(kSimpleGET_Transaction);
mock_transaction.url = kRangeGET_TransactionOK.url;
ScopedMockTransaction transaction(mock_transaction);
// Remove the cache-control and other headers so that the response cannot be
// conditionalized.
transaction.response_headers = "";
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 2;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
}
// Let 1st transaction complete headers phase for no range and read some part
// of the response and write in the cache.
std::string first_read;
MockHttpRequest request1(transaction);
{
request1.url = GURL(kRangeGET_TransactionOK.url);
auto& c = context_list[0];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
c->result =
c->trans->Start(&request1, c->callback.callback(), NetLogWithSource());
base::RunLoop().RunUntilIdle();
const int kBufferSize = 5;
scoped_refptr<IOBuffer> buffer =
base::MakeRefCounted<IOBuffer>(kBufferSize);
ReleaseBufferCompletionCallback cb(buffer.get());
c->result = c->trans->Read(buffer.get(), kBufferSize, cb.callback());
EXPECT_EQ(kBufferSize, cb.GetResult(c->result));
std::string data_read(buffer->data(), kBufferSize);
first_read = data_read;
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
}
// 2nd transaction requests a range.
ScopedMockTransaction range_transaction(kRangeGET_TransactionOK);
range_transaction.request_headers = "Range: bytes = 0-29\r\n" EXTRA_HEADER;
MockHttpRequest request2(range_transaction);
{
auto& c = context_list[1];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
c->result =
c->trans->Start(&request2, c->callback.callback(), NetLogWithSource());
base::RunLoop().RunUntilIdle();
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
}
// The second request would have doomed the 1st entry and created a new entry.
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
for (int i = 0; i < kNumTransactions; ++i) {
auto& c = context_list[i];
if (c->result == ERR_IO_PENDING)
c->result = c->callback.WaitForResult();
if (i == 0) {
ReadRemainingAndVerifyTransaction(c->trans.get(), first_read,
transaction);
continue;
}
range_transaction.data = "rg: 00-09 rg: 10-19 rg: 20-29 ";
ReadAndVerifyTransaction(c->trans.get(), range_transaction);
}
context_list.clear();
}
// Tests a 200 request and a simultaneous range request where conditionalization
// is possible.
TEST_F(HttpCacheTest, RangeGET_ParallelValidationCouldConditionalize) {
MockHttpCache cache;
MockTransaction mock_transaction(kSimpleGET_Transaction);
mock_transaction.url = kRangeGET_TransactionOK.url;
mock_transaction.data = kFullRangeData;
std::string response_headers_str = base::StrCat(
{"ETag: StrongOne\n",
"Content-Length:", base::NumberToString(strlen(kFullRangeData)), "\n"});
mock_transaction.response_headers = response_headers_str.c_str();
ScopedMockTransaction transaction(mock_transaction);
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 2;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
}
// Let 1st transaction complete headers phase for no range and read some part
// of the response and write in the cache.
std::string first_read;
MockHttpRequest request1(transaction);
{
request1.url = GURL(kRangeGET_TransactionOK.url);
auto& c = context_list[0];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
c->result =
c->trans->Start(&request1, c->callback.callback(), NetLogWithSource());
base::RunLoop().RunUntilIdle();
const int kBufferSize = 5;
scoped_refptr<IOBuffer> buffer =
base::MakeRefCounted<IOBuffer>(kBufferSize);
ReleaseBufferCompletionCallback cb(buffer.get());
c->result = c->trans->Read(buffer.get(), kBufferSize, cb.callback());
EXPECT_EQ(kBufferSize, cb.GetResult(c->result));
std::string data_read(buffer->data(), kBufferSize);
first_read = data_read;
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
}
// 2nd transaction requests a range.
ScopedMockTransaction range_transaction(kRangeGET_TransactionOK);
range_transaction.request_headers = "Range: bytes = 0-29\r\n" EXTRA_HEADER;
MockHttpRequest request2(range_transaction);
{
auto& c = context_list[1];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
c->result =
c->trans->Start(&request2, c->callback.callback(), NetLogWithSource());
base::RunLoop().RunUntilIdle();
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
}
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Finish and verify the first request.
auto& c0 = context_list[0];
c0->result = c0->callback.WaitForResult();
ReadRemainingAndVerifyTransaction(c0->trans.get(), first_read, transaction);
// And the second.
auto& c1 = context_list[1];
c1->result = c1->callback.WaitForResult();
range_transaction.data = "rg: 00-09 rg: 10-19 rg: 20-29 ";
ReadAndVerifyTransaction(c1->trans.get(), range_transaction);
context_list.clear();
}
// Tests parallel validation on range requests with overlapping ranges.
TEST_F(HttpCacheTest, RangeGET_ParallelValidationOverlappingRanges) {
MockHttpCache cache;
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 2;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
}
// Let 1st transaction complete headers phase for ranges 40-49.
std::string first_read;
MockHttpRequest request1(transaction);
{
auto& c = context_list[0];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
c->result =
c->trans->Start(&request1, c->callback.callback(), NetLogWithSource());
base::RunLoop().RunUntilIdle();
// Start writing to the cache so that MockDiskEntry::CouldBeSparse() returns
// true.
const int kBufferSize = 5;
scoped_refptr<IOBuffer> buffer =
base::MakeRefCounted<IOBuffer>(kBufferSize);
ReleaseBufferCompletionCallback cb(buffer.get());
c->result = c->trans->Read(buffer.get(), kBufferSize, cb.callback());
EXPECT_EQ(kBufferSize, cb.GetResult(c->result));
std::string data_read(buffer->data(), kBufferSize);
first_read = data_read;
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
}
// 2nd transaction requests ranges 30-49.
transaction.request_headers = "Range: bytes = 30-49\r\n" EXTRA_HEADER;
MockHttpRequest request2(transaction);
{
auto& c = context_list[1];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
c->result =
c->trans->Start(&request2, c->callback.callback(), NetLogWithSource());
base::RunLoop().RunUntilIdle();
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
}
std::string cache_key = request1.CacheKey();
EXPECT_TRUE(cache.IsWriterPresent(cache_key));
EXPECT_EQ(1, cache.GetCountDoneHeadersQueue(cache_key));
// Should have created another transaction for the uncached range.
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
for (int i = 0; i < kNumTransactions; ++i) {
auto& c = context_list[i];
if (c->result == ERR_IO_PENDING)
c->result = c->callback.WaitForResult();
if (i == 0) {
ReadRemainingAndVerifyTransaction(c->trans.get(), first_read,
transaction);
continue;
}
transaction.data = "rg: 30-39 rg: 40-49 ";
ReadAndVerifyTransaction(c->trans.get(), transaction);
}
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Fetch from the cache to check that ranges 30-49 have been successfully
// cached.
{
MockTransaction range_transaction(kRangeGET_TransactionOK);
range_transaction.request_headers = "Range: bytes = 30-49\r\n" EXTRA_HEADER;
range_transaction.data = "rg: 30-39 rg: 40-49 ";
std::string headers;
RunTransactionTestWithResponse(cache.http_cache(), range_transaction,
&headers);
Verify206Response(headers, 30, 49);
}
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Tests parallel validation on range requests with overlapping ranges and the
// impact of deleting the writer on transactions that have validated.
TEST_F(HttpCacheTest, RangeGET_ParallelValidationRestartDoneHeaders) {
MockHttpCache cache;
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 2;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
}
// Let 1st transaction complete headers phase for ranges 40-59.
std::string first_read;
transaction.request_headers = "Range: bytes = 40-59\r\n" EXTRA_HEADER;
MockHttpRequest request1(transaction);
{
auto& c = context_list[0];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
c->result =
c->trans->Start(&request1, c->callback.callback(), NetLogWithSource());
base::RunLoop().RunUntilIdle();
// Start writing to the cache so that MockDiskEntry::CouldBeSparse() returns
// true.
const int kBufferSize = 10;
scoped_refptr<IOBuffer> buffer =
base::MakeRefCounted<IOBuffer>(kBufferSize);
ReleaseBufferCompletionCallback cb(buffer.get());
c->result = c->trans->Read(buffer.get(), kBufferSize, cb.callback());
EXPECT_EQ(kBufferSize, cb.GetResult(c->result));
std::string data_read(buffer->data(), kBufferSize);
first_read = data_read;
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
}
// 2nd transaction requests ranges 30-59.
transaction.request_headers = "Range: bytes = 30-59\r\n" EXTRA_HEADER;
MockHttpRequest request2(transaction);
{
auto& c = context_list[1];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
c->result =
c->trans->Start(&request2, c->callback.callback(), NetLogWithSource());
base::RunLoop().RunUntilIdle();
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
}
std::string cache_key = request1.CacheKey();
EXPECT_TRUE(cache.IsWriterPresent(cache_key));
EXPECT_EQ(1, cache.GetCountDoneHeadersQueue(cache_key));
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Delete the writer transaction.
context_list[0].reset();
base::RunLoop().RunUntilIdle();
transaction.data = "rg: 30-39 rg: 40-49 rg: 50-59 ";
ReadAndVerifyTransaction(context_list[1]->trans.get(), transaction);
// Create another network transaction since the 2nd transaction is restarted.
// 30-39 will be read from network, 40-49 from the cache and 50-59 from the
// network.
EXPECT_EQ(4, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Fetch from the cache to check that ranges 30-49 have been successfully
// cached.
{
MockTransaction range_transaction(kRangeGET_TransactionOK);
range_transaction.request_headers = "Range: bytes = 30-49\r\n" EXTRA_HEADER;
range_transaction.data = "rg: 30-39 rg: 40-49 ";
std::string headers;
RunTransactionTestWithResponse(cache.http_cache(), range_transaction,
&headers);
Verify206Response(headers, 30, 49);
}
EXPECT_EQ(4, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// A test of doing a range request to a cached 301 response
TEST_F(HttpCacheTest, RangeGET_CachedRedirect) {
RangeTransactionServer handler;
handler.set_redirect(true);
MockHttpCache cache;
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = "Range: bytes = 0-\r\n" EXTRA_HEADER;
transaction.status = "HTTP/1.1 301 Moved Permanently";
transaction.response_headers = "Location: /elsewhere\nContent-Length:5";
transaction.data = "12345";
MockHttpRequest request(transaction);
TestCompletionCallback callback;
// Write to the cache.
{
std::unique_ptr<HttpTransaction> trans;
ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
if (rv == ERR_IO_PENDING)
rv = callback.WaitForResult();
ASSERT_THAT(rv, IsOk());
const HttpResponseInfo* info = trans->GetResponseInfo();
ASSERT_TRUE(info);
EXPECT_EQ(info->headers->response_code(), 301);
std::string location;
info->headers->EnumerateHeader(nullptr, "Location", &location);
EXPECT_EQ(location, "/elsewhere");
ReadAndVerifyTransaction(trans.get(), transaction);
}
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Active entries in the cache are not retired synchronously. Make
// sure the next run hits the MockHttpCache and open_count is
// correct.
base::RunLoop().RunUntilIdle();
// Read from the cache.
{
std::unique_ptr<HttpTransaction> trans;
ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
if (rv == ERR_IO_PENDING)
rv = callback.WaitForResult();
ASSERT_THAT(rv, IsOk());
const HttpResponseInfo* info = trans->GetResponseInfo();
ASSERT_TRUE(info);
EXPECT_EQ(info->headers->response_code(), 301);
std::string location;
info->headers->EnumerateHeader(nullptr, "Location", &location);
EXPECT_EQ(location, "/elsewhere");
trans->DoneReading();
}
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Now read the full body. This normally would not be done for a 301 by
// higher layers, but e.g. a 500 could hit a further bug here.
{
std::unique_ptr<HttpTransaction> trans;
ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
if (rv == ERR_IO_PENDING)
rv = callback.WaitForResult();
ASSERT_THAT(rv, IsOk());
const HttpResponseInfo* info = trans->GetResponseInfo();
ASSERT_TRUE(info);
EXPECT_EQ(info->headers->response_code(), 301);
std::string location;
info->headers->EnumerateHeader(nullptr, "Location", &location);
EXPECT_EQ(location, "/elsewhere");
ReadAndVerifyTransaction(trans.get(), transaction);
}
EXPECT_EQ(1, cache.network_layer()->transaction_count());
// No extra open since it picks up a previous ActiveEntry.
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// A transaction that fails to validate an entry, while attempting to write
// the response, should still get data to its consumer even if the attempt to
// create a new entry fails.
TEST_F(HttpCacheTest, SimpleGET_ValidationFailureWithCreateFailure) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
request.load_flags |= LOAD_VALIDATE_CACHE;
std::vector<std::unique_ptr<Context>> context_list;
// Create and run the first, successful, transaction to prime the cache.
context_list.push_back(std::make_unique<Context>());
auto& c1 = context_list.back();
c1->result = cache.CreateTransaction(&c1->trans);
ASSERT_THAT(c1->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, c1->trans->GetLoadState());
c1->result =
c1->trans->Start(&request, c1->callback.callback(), NetLogWithSource());
EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE, c1->trans->GetLoadState());
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(cache.IsWriterPresent(request.CacheKey()));
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Create and start the second transaction, which will fail its validation
// during the call to RunUntilIdle().
context_list.push_back(std::make_unique<Context>());
auto& c2 = context_list.back();
c2->result = cache.CreateTransaction(&c2->trans);
ASSERT_THAT(c2->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, c2->trans->GetLoadState());
c2->result =
c2->trans->Start(&request, c2->callback.callback(), NetLogWithSource());
// Expect idle at this point because we should be able to find and use the
// Active Entry that c1 created instead of waiting on the cache to open the
// entry.
EXPECT_EQ(LOAD_STATE_IDLE, c2->trans->GetLoadState());
cache.disk_cache()->set_fail_requests(true);
// The transaction, c2, should now attempt to validate the entry, fail when it
// receives a 200 OK response, attempt to create a new entry, fail to create,
// and then continue onward without an entry.
base::RunLoop().RunUntilIdle();
// All requests depend on the writer, and the writer is between Start and
// Read, i.e. idle.
for (auto& context : context_list) {
EXPECT_EQ(LOAD_STATE_IDLE, context->trans->GetLoadState());
}
// Confirm that both transactions correctly Read() the data.
for (auto& context : context_list) {
if (context->result == ERR_IO_PENDING)
context->result = context->callback.WaitForResult();
ReadAndVerifyTransaction(context->trans.get(), kSimpleGET_Transaction);
}
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Parallel validation results in 200.
TEST_F(HttpCacheTest, SimpleGET_ParallelValidationNoMatch) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
request.load_flags |= LOAD_VALIDATE_CACHE;
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 5;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
auto& c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
c->result =
c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
}
// All requests are waiting for the active entry.
for (auto& context : context_list) {
EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE, context->trans->GetLoadState());
}
// Allow all requests to move from the Create queue to the active entry.
base::RunLoop().RunUntilIdle();
// The first request should be a writer at this point, and the subsequent
// requests should have passed the validation phase and created their own
// entries since none of them matched the headers of the earlier one.
EXPECT_TRUE(cache.IsWriterPresent(request.CacheKey()));
EXPECT_EQ(5, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(5, cache.disk_cache()->create_count());
// All requests depend on the writer, and the writer is between Start and
// Read, i.e. idle.
for (auto& context : context_list) {
EXPECT_EQ(LOAD_STATE_IDLE, context->trans->GetLoadState());
}
for (auto& context : context_list) {
if (context->result == ERR_IO_PENDING)
context->result = context->callback.WaitForResult();
ReadAndVerifyTransaction(context->trans.get(), kSimpleGET_Transaction);
}
EXPECT_EQ(5, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(5, cache.disk_cache()->create_count());
}
TEST_F(HttpCacheTest, RangeGET_Enormous) {
// Test for how blockfile's limit on range namespace interacts with
// HttpCache::Transaction.
// See https://crbug.com/770694
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
auto backend_factory = std::make_unique<HttpCache::DefaultBackend>(
DISK_CACHE, CACHE_BACKEND_BLOCKFILE,
/*file_operations_factory=*/nullptr, temp_dir.GetPath(), 1024 * 1024,
false);
MockHttpCache cache(std::move(backend_factory));
RangeTransactionServer handler;
handler.set_length(2305843009213693962);
// Prime with a range it can store.
{
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = "Range: bytes = 0-9\r\n" EXTRA_HEADER;
transaction.data = "rg: 00-09 ";
MockHttpRequest request(transaction);
HttpResponseInfo response;
RunTransactionTestWithRequest(cache.http_cache(), transaction, request,
&response);
ASSERT_TRUE(response.headers != nullptr);
EXPECT_EQ(206, response.headers->response_code());
EXPECT_EQ(1, cache.network_layer()->transaction_count());
}
// Try with a range it can't. Should still work.
{
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers =
"Range: bytes = "
"2305843009213693952-2305843009213693961\r\n" EXTRA_HEADER;
transaction.data = "rg: 52-61 ";
MockHttpRequest request(transaction);
HttpResponseInfo response;
RunTransactionTestWithRequest(cache.http_cache(), transaction, request,
&response);
ASSERT_TRUE(response.headers != nullptr);
EXPECT_EQ(206, response.headers->response_code());
EXPECT_EQ(2, cache.network_layer()->transaction_count());
}
// Can't actually cache it due to backend limitations. If the network
// transaction count is 2, this test isn't covering what it needs to.
{
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers =
"Range: bytes = "
"2305843009213693952-2305843009213693961\r\n" EXTRA_HEADER;
transaction.data = "rg: 52-61 ";
MockHttpRequest request(transaction);
HttpResponseInfo response;
RunTransactionTestWithRequest(cache.http_cache(), transaction, request,
&response);
ASSERT_TRUE(response.headers != nullptr);
EXPECT_EQ(206, response.headers->response_code());
EXPECT_EQ(3, cache.network_layer()->transaction_count());
}
}
// Parallel validation results in 200 for 1 transaction and validation matches
// for subsequent transactions.
TEST_F(HttpCacheTest, SimpleGET_ParallelValidationNoMatch1) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
MockTransaction transaction(kSimpleGET_Transaction);
transaction.load_flags |= LOAD_VALIDATE_CACHE;
MockHttpRequest validate_request(transaction);
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 5;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
auto& c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
MockHttpRequest* this_request = &request;
if (i == 1)
this_request = &validate_request;
c->result = c->trans->Start(this_request, c->callback.callback(),
NetLogWithSource());
}
// All requests are waiting for the active entry.
for (auto& context : context_list) {
EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE, context->trans->GetLoadState());
}
// Allow all requests to move from the Create queue to the active entry.
base::RunLoop().RunUntilIdle();
// The new entry will have all the transactions except the first one which
// will continue in the doomed entry.
EXPECT_EQ(kNumTransactions - 1,
cache.GetCountWriterTransactions(validate_request.CacheKey()));
EXPECT_EQ(1, cache.disk_cache()->doomed_count());
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
for (auto& context : context_list) {
EXPECT_EQ(LOAD_STATE_IDLE, context->trans->GetLoadState());
}
for (auto& context : context_list) {
if (context->result == ERR_IO_PENDING)
context->result = context->callback.WaitForResult();
ReadAndVerifyTransaction(context->trans.get(), kSimpleGET_Transaction);
}
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests that a GET followed by a DELETE results in DELETE immediately starting
// the headers phase and the entry is doomed.
TEST_F(HttpCacheTest, SimpleGET_ParallelValidationDelete) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
request.load_flags |= LOAD_VALIDATE_CACHE;
MockHttpRequest delete_request(kSimpleGET_Transaction);
delete_request.method = "DELETE";
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 2;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
auto& c = context_list[i];
MockHttpRequest* this_request = &request;
if (i == 1)
this_request = &delete_request;
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
c->result = c->trans->Start(this_request, c->callback.callback(),
NetLogWithSource());
}
// All requests are waiting for the active entry.
for (auto& context : context_list) {
EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE, context->trans->GetLoadState());
}
// Allow all requests to move from the Create queue to the active entry.
base::RunLoop().RunUntilIdle();
// The first request should be a writer at this point, and the subsequent
// request should have passed the validation phase and doomed the existing
// entry.
EXPECT_TRUE(cache.disk_cache()->IsDiskEntryDoomed(request.CacheKey()));
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// All requests depend on the writer, and the writer is between Start and
// Read, i.e. idle.
for (auto& context : context_list) {
EXPECT_EQ(LOAD_STATE_IDLE, context->trans->GetLoadState());
}
for (auto& context : context_list) {
if (context->result == ERR_IO_PENDING)
context->result = context->callback.WaitForResult();
ReadAndVerifyTransaction(context->trans.get(), kSimpleGET_Transaction);
}
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Tests that a transaction which is in validated queue can be destroyed without
// any impact to other transactions.
TEST_F(HttpCacheTest, SimpleGET_ParallelValidationCancelValidated) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
MockTransaction transaction(kSimpleGET_Transaction);
transaction.load_flags |= LOAD_ONLY_FROM_CACHE;
MockHttpRequest read_only_request(transaction);
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 2;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
auto& c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
MockHttpRequest* current_request = i == 1 ? &read_only_request : &request;
c->result = c->trans->Start(current_request, c->callback.callback(),
NetLogWithSource());
}
// Allow all requests to move from the Create queue to the active entry.
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
std::string cache_key = request.CacheKey();
EXPECT_EQ(1, cache.GetCountWriterTransactions(cache_key));
EXPECT_EQ(1, cache.GetCountDoneHeadersQueue(cache_key));
context_list[1].reset();
EXPECT_EQ(0, cache.GetCountDoneHeadersQueue(cache_key));
// Complete the rest of the transactions.
for (auto& context : context_list) {
if (!context)
continue;
ReadAndVerifyTransaction(context->trans.get(), kSimpleGET_Transaction);
}
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Tests that an idle writer transaction can be deleted without impacting the
// existing writers.
TEST_F(HttpCacheTest, SimpleGET_ParallelWritingCancelIdleTransaction) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 2;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
auto& c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
c->result =
c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
}
// Allow all requests to move from the Create queue to the active entry.
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Both transactions would be added to writers.
std::string cache_key = request.CacheKey();
EXPECT_EQ(kNumTransactions, cache.GetCountWriterTransactions(cache_key));
context_list[1].reset();
EXPECT_EQ(kNumTransactions - 1, cache.GetCountWriterTransactions(cache_key));
// Complete the rest of the transactions.
for (auto& context : context_list) {
if (!context)
continue;
ReadAndVerifyTransaction(context->trans.get(), kSimpleGET_Transaction);
}
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Tests that a transaction which is in validated queue can timeout and start
// the headers phase again.
TEST_F(HttpCacheTest, SimpleGET_ParallelValidationValidatedTimeout) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
MockTransaction transaction(kSimpleGET_Transaction);
transaction.load_flags |= LOAD_ONLY_FROM_CACHE;
MockHttpRequest read_only_request(transaction);
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 2;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
auto& c = context_list[i];
MockHttpRequest* this_request = &request;
if (i == 1) {
this_request = &read_only_request;
cache.SimulateCacheLockTimeoutAfterHeaders();
}
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
c->result = c->trans->Start(this_request, c->callback.callback(),
NetLogWithSource());
}
// Allow all requests to move from the Create queue to the active entry.
base::RunLoop().RunUntilIdle();
// The first request should be a writer at this point, and the subsequent
// requests should have completed validation, timed out and restarted.
// Since it is a read only request, it will error out.
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
std::string cache_key = request.CacheKey();
EXPECT_TRUE(cache.IsWriterPresent(cache_key));
EXPECT_EQ(0, cache.GetCountDoneHeadersQueue(cache_key));
base::RunLoop().RunUntilIdle();
int rv = context_list[1]->callback.WaitForResult();
EXPECT_EQ(ERR_CACHE_MISS, rv);
ReadAndVerifyTransaction(context_list[0]->trans.get(),
kSimpleGET_Transaction);
}
// Tests that a transaction which is in readers can be destroyed without
// any impact to other transactions.
TEST_F(HttpCacheTest, SimpleGET_ParallelValidationCancelReader) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
MockTransaction transaction(kSimpleGET_Transaction);
transaction.load_flags |= LOAD_VALIDATE_CACHE;
MockHttpRequest validate_request(transaction);
int kNumTransactions = 4;
std::vector<std::unique_ptr<Context>> context_list;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
auto& c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
MockHttpRequest* this_request = &request;
if (i == 3) {
this_request = &validate_request;
c->trans->SetBeforeNetworkStartCallback(base::BindOnce(&DeferCallback));
}
c->result = c->trans->Start(this_request, c->callback.callback(),
NetLogWithSource());
}
// Allow all requests to move from the Create queue to the active entry.
base::RunLoop().RunUntilIdle();
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
std::string cache_key = request.CacheKey();
EXPECT_EQ(kNumTransactions - 1, cache.GetCountWriterTransactions(cache_key));
EXPECT_TRUE(cache.IsHeadersTransactionPresent(cache_key));
// Complete the response body.
ReadAndVerifyTransaction(context_list[0]->trans.get(),
kSimpleGET_Transaction);
// Rest of the transactions should move to readers.
EXPECT_FALSE(cache.IsWriterPresent(cache_key));
EXPECT_EQ(kNumTransactions - 2, cache.GetCountReaders(cache_key));
EXPECT_EQ(0, cache.GetCountDoneHeadersQueue(cache_key));
EXPECT_TRUE(cache.IsHeadersTransactionPresent(cache_key));
// Add 2 new transactions.
kNumTransactions = 6;
for (int i = 4; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
auto& c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
c->result =
c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
}
EXPECT_EQ(2, cache.GetCountAddToEntryQueue(cache_key));
// Delete a reader.
context_list[1].reset();
// Deleting the reader did not impact any other transaction.
EXPECT_EQ(1, cache.GetCountReaders(cache_key));
EXPECT_EQ(2, cache.GetCountAddToEntryQueue(cache_key));
EXPECT_TRUE(cache.IsHeadersTransactionPresent(cache_key));
// Resume network start for headers_transaction. It will doom the entry as it
// will be a 200 and will go to network for the response body.
context_list[3]->trans->ResumeNetworkStart();
// The pending transactions will be added to a new entry as writers.
base::RunLoop().RunUntilIdle();
EXPECT_EQ(3, cache.GetCountWriterTransactions(cache_key));
// Complete the rest of the transactions.
for (int i = 2; i < kNumTransactions; ++i) {
ReadAndVerifyTransaction(context_list[i]->trans.get(),
kSimpleGET_Transaction);
}
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests that when the only writer goes away, it immediately cleans up rather
// than wait for the network request to finish. See https://crbug.com/804868.
TEST_F(HttpCacheTest, SimpleGET_HangingCacheWriteCleanup) {
MockHttpCache mock_cache;
MockHttpRequest request(kSimpleGET_Transaction);
std::unique_ptr<HttpTransaction> transaction;
mock_cache.CreateTransaction(&transaction);
TestCompletionCallback callback;
int result =
transaction->Start(&request, callback.callback(), NetLogWithSource());
// Get the transaction ready to read.
result = callback.GetResult(result);
// Read the first byte.
scoped_refptr<IOBuffer> buffer = base::MakeRefCounted<IOBuffer>(1);
ReleaseBufferCompletionCallback buffer_callback(buffer.get());
result = transaction->Read(buffer.get(), 1, buffer_callback.callback());
EXPECT_EQ(1, buffer_callback.GetResult(result));
// Read the second byte, but leave the cache write hanging.
std::string cache_key = request.CacheKey();
scoped_refptr<MockDiskEntry> entry =
mock_cache.disk_cache()->GetDiskEntryRef(cache_key);
entry->SetDefer(MockDiskEntry::DEFER_WRITE);
buffer = base::MakeRefCounted<IOBuffer>(1);
ReleaseBufferCompletionCallback buffer_callback2(buffer.get());
result = transaction->Read(buffer.get(), 1, buffer_callback2.callback());
EXPECT_EQ(ERR_IO_PENDING, result);
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(mock_cache.IsWriterPresent(cache_key));
// At this point the next byte should have been read from the network but is
// waiting to be written to the cache. Destroy the transaction and make sure
// that everything has been cleaned up.
transaction = nullptr;
EXPECT_FALSE(mock_cache.IsWriterPresent(cache_key));
EXPECT_FALSE(mock_cache.network_layer()->last_transaction());
}
// Tests that a transaction writer can be destroyed mid-read.
// A waiting for read transaction should be able to read the data that was
// driven by the Read started by the cancelled writer.
TEST_F(HttpCacheTest, SimpleGET_ParallelWritingCancelWriter) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
MockTransaction transaction(kSimpleGET_Transaction);
transaction.load_flags |= LOAD_VALIDATE_CACHE;
MockHttpRequest validate_request(transaction);
const int kNumTransactions = 3;
std::vector<std::unique_ptr<Context>> context_list;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
auto& c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
MockHttpRequest* this_request = &request;
if (i == 2) {
this_request = &validate_request;
c->trans->SetBeforeNetworkStartCallback(base::BindOnce(&DeferCallback));
}
c->result = c->trans->Start(this_request, c->callback.callback(),
NetLogWithSource());
}
// Allow all requests to move from the Create queue to the active entry.
base::RunLoop().RunUntilIdle();
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
std::string cache_key = validate_request.CacheKey();
EXPECT_TRUE(cache.IsHeadersTransactionPresent(cache_key));
EXPECT_EQ(2, cache.GetCountWriterTransactions(cache_key));
// Initiate Read from both writers and kill 1 of them mid-read.
std::string first_read;
for (int i = 0; i < 2; i++) {
auto& c = context_list[i];
const int kBufferSize = 5;
scoped_refptr<IOBuffer> buffer =
base::MakeRefCounted<IOBuffer>(kBufferSize);
ReleaseBufferCompletionCallback cb(buffer.get());
c->result = c->trans->Read(buffer.get(), kBufferSize, cb.callback());
EXPECT_EQ(ERR_IO_PENDING, c->result);
// Deleting one writer at this point will not impact other transactions
// since writers contain more transactions.
if (i == 1) {
context_list[0].reset();
base::RunLoop().RunUntilIdle();
EXPECT_EQ(kBufferSize, cb.GetResult(c->result));
std::string data_read(buffer->data(), kBufferSize);
first_read = data_read;
}
}
// Resume network start for headers_transaction. It will doom the existing
// entry and create a new entry due to validation returning a 200.
auto& c = context_list[2];
c->trans->ResumeNetworkStart();
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1, cache.GetCountWriterTransactions(cache_key));
// Complete the rest of the transactions.
for (int i = 0; i < kNumTransactions; i++) {
auto& context = context_list[i];
if (!context)
continue;
if (i == 1)
ReadRemainingAndVerifyTransaction(context->trans.get(), first_read,
kSimpleGET_Transaction);
else
ReadAndVerifyTransaction(context->trans.get(), kSimpleGET_Transaction);
}
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests the case when network read failure happens. Idle and waiting
// transactions should fail and headers transaction should be restarted.
TEST_F(HttpCacheTest, SimpleGET_ParallelWritingNetworkReadFailed) {
MockHttpCache cache;
ScopedMockTransaction fail_transaction(kSimpleGET_Transaction);
fail_transaction.read_return_code = ERR_INTERNET_DISCONNECTED;
MockHttpRequest failing_request(fail_transaction);
MockHttpRequest request(kSimpleGET_Transaction);
MockTransaction transaction(kSimpleGET_Transaction);
transaction.load_flags |= LOAD_ONLY_FROM_CACHE;
MockHttpRequest read_request(transaction);
const int kNumTransactions = 4;
std::vector<std::unique_ptr<Context>> context_list;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
auto& c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
MockHttpRequest* this_request = &request;
if (i == 0)
this_request = &failing_request;
if (i == 3)
this_request = &read_request;
c->result = c->trans->Start(this_request, c->callback.callback(),
NetLogWithSource());
}
// Allow all requests to move from the Create queue to the active entry.
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
std::string cache_key = read_request.CacheKey();
EXPECT_EQ(3, cache.GetCountWriterTransactions(cache_key));
EXPECT_EQ(1, cache.GetCountDoneHeadersQueue(cache_key));
// Initiate Read from two writers and let the first get a network failure.
for (int i = 0; i < 2; i++) {
auto& c = context_list[i];
const int kBufferSize = 5;
scoped_refptr<IOBuffer> buffer =
base::MakeRefCounted<IOBuffer>(kBufferSize);
c->result =
c->trans->Read(buffer.get(), kBufferSize, c->callback.callback());
EXPECT_EQ(ERR_IO_PENDING, c->result);
}
base::RunLoop().RunUntilIdle();
for (int i = 0; i < 2; i++) {
auto& c = context_list[i];
c->result = c->callback.WaitForResult();
EXPECT_EQ(ERR_INTERNET_DISCONNECTED, c->result);
}
// The entry should have been doomed and destroyed and the headers transaction
// restarted. Since headers transaction is read-only it will error out.
auto& read_only = context_list[3];
read_only->result = read_only->callback.WaitForResult();
EXPECT_EQ(ERR_CACHE_MISS, read_only->result);
EXPECT_FALSE(cache.IsWriterPresent(cache_key));
// Invoke Read on the 3rd transaction and it should get the error code back.
auto& c = context_list[2];
const int kBufferSize = 5;
scoped_refptr<IOBuffer> buffer = base::MakeRefCounted<IOBuffer>(kBufferSize);
c->result = c->trans->Read(buffer.get(), kBufferSize, c->callback.callback());
EXPECT_EQ(ERR_INTERNET_DISCONNECTED, c->result);
}
// Tests the case when cache write failure happens. Idle and waiting
// transactions should fail and headers transaction should be restarted.
TEST_F(HttpCacheTest, SimpleGET_ParallelWritingCacheWriteFailed) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
MockTransaction transaction(kSimpleGET_Transaction);
transaction.load_flags |= LOAD_ONLY_FROM_CACHE;
MockHttpRequest read_request(transaction);
const int kNumTransactions = 4;
std::vector<std::unique_ptr<Context>> context_list;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
auto& c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
MockHttpRequest* this_request = &request;
if (i == 3)
this_request = &read_request;
c->result = c->trans->Start(this_request, c->callback.callback(),
NetLogWithSource());
}
// Allow all requests to move from the Create queue to the active entry.
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
std::string cache_key = read_request.CacheKey();
EXPECT_EQ(3, cache.GetCountWriterTransactions(cache_key));
EXPECT_EQ(1, cache.GetCountDoneHeadersQueue(cache_key));
// Initiate Read from two writers and let the first get a cache write failure.
cache.disk_cache()->set_soft_failures_mask(MockDiskEntry::FAIL_ALL);
// We have to open the entry again to propagate the failure flag.
disk_cache::Entry* en;
cache.OpenBackendEntry(cache_key, &en);
en->Close();
const int kBufferSize = 5;
std::vector<scoped_refptr<IOBuffer>> buffer(
3, base::MakeRefCounted<IOBuffer>(kBufferSize));
for (int i = 0; i < 2; i++) {
auto& c = context_list[i];
c->result =
c->trans->Read(buffer[i].get(), kBufferSize, c->callback.callback());
EXPECT_EQ(ERR_IO_PENDING, c->result);
}
std::string first_read;
base::RunLoop().RunUntilIdle();
for (int i = 0; i < 2; i++) {
auto& c = context_list[i];
c->result = c->callback.WaitForResult();
if (i == 0) {
EXPECT_EQ(5, c->result);
std::string data_read(buffer[i]->data(), kBufferSize);
first_read = data_read;
} else {
EXPECT_EQ(ERR_CACHE_WRITE_FAILURE, c->result);
}
}
// The entry should have been doomed and destroyed and the headers transaction
// restarted. Since headers transaction is read-only it will error out.
auto& read_only = context_list[3];
read_only->result = read_only->callback.WaitForResult();
EXPECT_EQ(ERR_CACHE_MISS, read_only->result);
EXPECT_FALSE(cache.IsWriterPresent(cache_key));
// Invoke Read on the 3rd transaction and it should get the error code back.
auto& c = context_list[2];
c->result =
c->trans->Read(buffer[2].get(), kBufferSize, c->callback.callback());
EXPECT_EQ(ERR_CACHE_WRITE_FAILURE, c->result);
// The first transaction should be able to continue to read from the network
// without writing to the cache.
auto& succ_read = context_list[0];
ReadRemainingAndVerifyTransaction(succ_read->trans.get(), first_read,
kSimpleGET_Transaction);
}
// Tests that POST requests do not join existing transactions for parallel
// writing to the cache. Note that two POSTs only map to the same entry if their
// upload data identifier is same and that should happen for back-forward case
// (LOAD_ONLY_FROM_CACHE). But this test tests without LOAD_ONLY_FROM_CACHE
// because read-only transactions anyways do not join parallel writing.
// TODO(shivanisha) Testing this because it is allowed by the code but looks
// like the code should disallow two POSTs without LOAD_ONLY_FROM_CACHE with the
// same upload data identifier to map to the same entry.
TEST_F(HttpCacheTest, SimplePOST_ParallelWritingDisallowed) {
MockHttpCache cache;
MockTransaction transaction(kSimplePOST_Transaction);
const int64_t kUploadId = 1; // Just a dummy value.
std::vector<std::unique_ptr<UploadElementReader>> element_readers;
element_readers.push_back(
std::make_unique<UploadBytesElementReader>("hello", 5));
ElementsUploadDataStream upload_data_stream(std::move(element_readers),
kUploadId);
// Note that both transactions should have the same upload_data_stream
// identifier to map to the same entry.
transaction.load_flags = LOAD_SKIP_CACHE_VALIDATION;
MockHttpRequest request(transaction);
request.upload_data_stream = &upload_data_stream;
const int kNumTransactions = 2;
std::vector<std::unique_ptr<Context>> context_list;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
auto& c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
c->result =
c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
// Complete the headers phase request.
base::RunLoop().RunUntilIdle();
}
std::string cache_key = request.CacheKey();
// Only the 1st transaction gets added to writers.
EXPECT_EQ(1, cache.GetCountDoneHeadersQueue(cache_key));
EXPECT_EQ(1, cache.GetCountWriterTransactions(cache_key));
// Read the 1st transaction.
ReadAndVerifyTransaction(context_list[0]->trans.get(),
kSimplePOST_Transaction);
// 2nd transaction should now become a reader.
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1, cache.GetCountReaders(cache_key));
EXPECT_EQ(0, cache.GetCountDoneHeadersQueue(cache_key));
ReadAndVerifyTransaction(context_list[1]->trans.get(),
kSimplePOST_Transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
context_list.clear();
}
// Tests the case when parallel writing succeeds. Tests both idle and waiting
// transactions.
TEST_F(HttpCacheTest, SimpleGET_ParallelWritingSuccess) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
MockTransaction transaction(kSimpleGET_Transaction);
transaction.load_flags |= LOAD_ONLY_FROM_CACHE;
MockHttpRequest read_request(transaction);
const int kNumTransactions = 4;
std::vector<std::unique_ptr<Context>> context_list;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
auto& c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
MockHttpRequest* this_request = &request;
if (i == 3)
this_request = &read_request;
c->result = c->trans->Start(this_request, c->callback.callback(),
NetLogWithSource());
}
// Allow all requests to move from the Create queue to the active entry.
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
std::string cache_key = request.CacheKey();
EXPECT_EQ(3, cache.GetCountWriterTransactions(cache_key));
EXPECT_EQ(1, cache.GetCountDoneHeadersQueue(cache_key));
// Initiate Read from two writers.
const int kBufferSize = 5;
std::vector<scoped_refptr<IOBuffer>> buffer(
3, base::MakeRefCounted<IOBuffer>(kBufferSize));
for (int i = 0; i < 2; i++) {
auto& c = context_list[i];
c->result =
c->trans->Read(buffer[i].get(), kBufferSize, c->callback.callback());
EXPECT_EQ(ERR_IO_PENDING, c->result);
}
std::vector<std::string> first_read(2);
base::RunLoop().RunUntilIdle();
for (int i = 0; i < 2; i++) {
auto& c = context_list[i];
c->result = c->callback.WaitForResult();
EXPECT_EQ(5, c->result);
std::string data_read(buffer[i]->data(), kBufferSize);
first_read[i] = data_read;
}
EXPECT_EQ(first_read[0], first_read[1]);
// The first transaction should be able to continue to read from the network
// without writing to the cache.
for (int i = 0; i < 2; i++) {
auto& c = context_list[i];
ReadRemainingAndVerifyTransaction(c->trans.get(), first_read[i],
kSimpleGET_Transaction);
if (i == 0) {
// Remaining transactions should now be readers.
EXPECT_EQ(3, cache.GetCountReaders(cache_key));
}
}
// Verify the rest of the transactions.
for (int i = 2; i < kNumTransactions; i++) {
auto& c = context_list[i];
ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
}
context_list.clear();
}
// Tests the case when parallel writing involves things bigger than what cache
// can store. In this case, the best we can do is re-fetch it.
TEST_F(HttpCacheTest, SimpleGET_ParallelWritingHuge) {
MockHttpCache cache;
cache.disk_cache()->set_max_file_size(10);
MockTransaction transaction(kSimpleGET_Transaction);
std::string response_headers = base::StrCat(
{kSimpleGET_Transaction.response_headers, "Content-Length: ",
base::NumberToString(strlen(kSimpleGET_Transaction.data)), "\n"});
transaction.response_headers = response_headers.c_str();
AddMockTransaction(&transaction);
MockHttpRequest request(transaction);
const int kNumTransactions = 4;
std::vector<std::unique_ptr<Context>> context_list;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
auto& c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
MockHttpRequest* this_request = &request;
c->result = c->trans->Start(this_request, c->callback.callback(),
NetLogWithSource());
}
// Start them up.
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
std::string cache_key = request.CacheKey();
EXPECT_EQ(1, cache.GetCountWriterTransactions(cache_key));
EXPECT_EQ(kNumTransactions - 1, cache.GetCountDoneHeadersQueue(cache_key));
// Initiate Read from first transaction.
const int kBufferSize = 5;
std::vector<scoped_refptr<IOBuffer>> buffer(
kNumTransactions, base::MakeRefCounted<IOBuffer>(kBufferSize));
auto& c = context_list[0];
c->result =
c->trans->Read(buffer[0].get(), kBufferSize, c->callback.callback());
EXPECT_EQ(ERR_IO_PENDING, c->result);
// ... and complete it.
std::vector<std::string> first_read(kNumTransactions);
base::RunLoop().RunUntilIdle();
c->result = c->callback.WaitForResult();
EXPECT_EQ(kBufferSize, c->result);
std::string data_read(buffer[0]->data(), kBufferSize);
first_read[0] = data_read;
EXPECT_EQ("<html", first_read[0]);
// Complete all of them.
for (int i = 0; i < kNumTransactions; i++) {
ReadRemainingAndVerifyTransaction(context_list[i]->trans.get(),
first_read[i], kSimpleGET_Transaction);
}
// Sadly all of them have to hit the network
EXPECT_EQ(kNumTransactions, cache.network_layer()->transaction_count());
context_list.clear();
RemoveMockTransaction(&transaction);
}
// Tests that network transaction's info is saved correctly when a writer
// transaction that created the network transaction becomes a reader. Also
// verifies that the network bytes are only attributed to the transaction that
// created the network transaction.
TEST_F(HttpCacheTest, SimpleGET_ParallelWritingVerifyNetworkBytes) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
const int kNumTransactions = 2;
std::vector<std::unique_ptr<Context>> context_list;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
auto& c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
c->result =
c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
}
// Allow all requests to move from the Create queue to the active entry.
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
std::string cache_key = request.CacheKey();
EXPECT_EQ(2, cache.GetCountWriterTransactions(cache_key));
EXPECT_EQ(0, cache.GetCountDoneHeadersQueue(cache_key));
// Get the network bytes read by the first transaction.
int total_received_bytes = context_list[0]->trans->GetTotalReceivedBytes();
EXPECT_GT(total_received_bytes, 0);
// Complete Read by the 2nd transaction so that the 1st transaction that
// created the network transaction is now a reader.
ReadAndVerifyTransaction(context_list[1]->trans.get(),
kSimpleGET_Transaction);
EXPECT_EQ(1, cache.GetCountReaders(cache_key));
// Verify that the network bytes read are not attributed to the 2nd
// transaction but to the 1st.
EXPECT_EQ(0, context_list[1]->trans->GetTotalReceivedBytes());
EXPECT_GE(total_received_bytes,
context_list[0]->trans->GetTotalReceivedBytes());
ReadAndVerifyTransaction(context_list[0]->trans.get(),
kSimpleGET_Transaction);
}
// Tests than extra Read from the consumer should not hang/crash the browser.
TEST_F(HttpCacheTest, SimpleGET_ExtraRead) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
Context c;
c.result = cache.CreateTransaction(&c.trans);
ASSERT_THAT(c.result, IsOk());
c.result =
c.trans->Start(&request, c.callback.callback(), NetLogWithSource());
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
std::string cache_key = request.CacheKey();
EXPECT_EQ(1, cache.GetCountWriterTransactions(cache_key));
EXPECT_EQ(0, cache.GetCountDoneHeadersQueue(cache_key));
ReadAndVerifyTransaction(c.trans.get(), kSimpleGET_Transaction);
// Perform an extra Read.
const int kBufferSize = 10;
scoped_refptr<IOBuffer> buffer = base::MakeRefCounted<IOBuffer>(kBufferSize);
c.result = c.trans->Read(buffer.get(), kBufferSize, c.callback.callback());
EXPECT_EQ(0, c.result);
}
// Tests when a writer is destroyed mid-read, all the other writer transactions
// can continue writing to the entry.
TEST_F(HttpCacheTest, SimpleGET_ParallelValidationCancelWriter) {
MockHttpCache cache;
ScopedMockTransaction transaction(kSimpleGET_Transaction);
transaction.response_headers =
"Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
"Content-Length: 22\n"
"Etag: \"foopy\"\n";
MockHttpRequest request(transaction);
const int kNumTransactions = 3;
std::vector<std::unique_ptr<Context>> context_list;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
auto& c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
c->result =
c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
}
// Allow all requests to move from the Create queue to the active entry.
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
std::string cache_key = request.CacheKey();
EXPECT_EQ(kNumTransactions, cache.GetCountWriterTransactions(cache_key));
// Let first transaction read some bytes.
{
auto& c = context_list[0];
const int kBufferSize = 5;
scoped_refptr<IOBuffer> buffer =
base::MakeRefCounted<IOBuffer>(kBufferSize);
ReleaseBufferCompletionCallback cb(buffer.get());
c->result = c->trans->Read(buffer.get(), kBufferSize, cb.callback());
EXPECT_EQ(kBufferSize, cb.GetResult(c->result));
}
// Deleting the active transaction at this point will not impact the other
// transactions since there are other transactions in writers.
context_list[0].reset();
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Complete the rest of the transactions.
for (auto& context : context_list) {
if (!context)
continue;
ReadAndVerifyTransaction(context->trans.get(), kSimpleGET_Transaction);
}
}
// Tests that when StopCaching is invoked on a writer, dependent transactions
// are restarted.
TEST_F(HttpCacheTest, SimpleGET_ParallelValidationStopCaching) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
MockTransaction transaction(kSimpleGET_Transaction);
transaction.load_flags |= LOAD_ONLY_FROM_CACHE;
MockHttpRequest read_only_request(transaction);
const int kNumTransactions = 2;
std::vector<std::unique_ptr<Context>> context_list;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
auto& c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
MockHttpRequest* this_request = &request;
if (i == 1) {
this_request = &read_only_request;
}
c->result = c->trans->Start(this_request, c->callback.callback(),
NetLogWithSource());
}
// Allow all requests to move from the Create queue to the active entry.
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
std::string cache_key = request.CacheKey();
EXPECT_EQ(kNumTransactions - 1, cache.GetCountWriterTransactions(cache_key));
EXPECT_EQ(1, cache.GetCountDoneHeadersQueue(cache_key));
// Invoking StopCaching on the writer will lead to dooming the entry and
// restarting the validated transactions. Since it is a read-only transaction
// it will error out.
context_list[0]->trans->StopCaching();
base::RunLoop().RunUntilIdle();
int rv = context_list[1]->callback.WaitForResult();
EXPECT_EQ(ERR_CACHE_MISS, rv);
ReadAndVerifyTransaction(context_list[0]->trans.get(),
kSimpleGET_Transaction);
}
// Tests that when StopCaching is invoked on a writer transaction, it is a
// no-op if there are other writer transactions.
TEST_F(HttpCacheTest, SimpleGET_ParallelWritersStopCachingNoOp) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
MockTransaction transaction(kSimpleGET_Transaction);
transaction.load_flags |= LOAD_VALIDATE_CACHE;
MockHttpRequest validate_request(transaction);
const int kNumTransactions = 3;
std::vector<std::unique_ptr<Context>> context_list;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
auto& c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
MockHttpRequest* this_request = &request;
if (i == 2) {
this_request = &validate_request;
c->trans->SetBeforeNetworkStartCallback(base::BindOnce(&DeferCallback));
}
c->result = c->trans->Start(this_request, c->callback.callback(),
NetLogWithSource());
}
// Allow all requests to move from the Create queue to the active entry.
base::RunLoop().RunUntilIdle();
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
std::string cache_key = request.CacheKey();
EXPECT_TRUE(cache.IsHeadersTransactionPresent(cache_key));
EXPECT_EQ(kNumTransactions - 1, cache.GetCountWriterTransactions(cache_key));
// Invoking StopCaching on the writer will be a no-op since there are multiple
// transaction in writers.
context_list[0]->trans->StopCaching();
// Resume network start for headers_transaction.
auto& c = context_list[2];
c->trans->ResumeNetworkStart();
base::RunLoop().RunUntilIdle();
// After validation old entry will be doomed and headers_transaction will be
// added to the new entry.
EXPECT_EQ(1, cache.GetCountWriterTransactions(cache_key));
// Complete the rest of the transactions.
for (auto& context : context_list) {
if (!context)
continue;
ReadAndVerifyTransaction(context->trans.get(), kSimpleGET_Transaction);
}
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests that a transaction is currently in headers phase and is destroyed
// leading to destroying the entry.
TEST_F(HttpCacheTest, SimpleGET_ParallelValidationCancelHeaders) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
const int kNumTransactions = 2;
std::vector<std::unique_ptr<Context>> context_list;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
auto& c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
if (i == 0)
c->trans->SetBeforeNetworkStartCallback(base::BindOnce(&DeferCallback));
c->result =
c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
}
base::RunLoop().RunUntilIdle();
std::string cache_key = request.CacheKey();
EXPECT_TRUE(cache.IsHeadersTransactionPresent(cache_key));
EXPECT_EQ(1, cache.GetCountAddToEntryQueue(cache_key));
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Delete the headers transaction.
context_list[0].reset();
base::RunLoop().RunUntilIdle();
// Complete the rest of the transactions.
for (auto& context : context_list) {
if (!context)
continue;
ReadAndVerifyTransaction(context->trans.get(), kSimpleGET_Transaction);
}
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Similar to the above test, except here cache write fails and the
// validated transactions should be restarted.
TEST_F(HttpCacheTest, SimpleGET_ParallelWritersFailWrite) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
const int kNumTransactions = 5;
std::vector<std::unique_ptr<Context>> context_list;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
auto& c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
c->result =
c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
}
// All requests are waiting for the active entry.
for (auto& context : context_list) {
EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE, context->trans->GetLoadState());
}
// Allow all requests to move from the Create queue to the active entry.
base::RunLoop().RunUntilIdle();
// All transactions become writers.
std::string cache_key = request.CacheKey();
EXPECT_EQ(kNumTransactions, cache.GetCountWriterTransactions(cache_key));
// All requests depend on the writer, and the writer is between Start and
// Read, i.e. idle.
for (auto& context : context_list) {
EXPECT_EQ(LOAD_STATE_IDLE, context->trans->GetLoadState());
}
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Fail the request.
cache.disk_cache()->set_soft_failures_mask(MockDiskEntry::FAIL_ALL);
// We have to open the entry again to propagate the failure flag.
disk_cache::Entry* en;
cache.OpenBackendEntry(cache_key, &en);
en->Close();
for (int i = 0; i < kNumTransactions; ++i) {
auto& c = context_list[i];
if (c->result == ERR_IO_PENDING)
c->result = c->callback.WaitForResult();
if (i == 1) {
// The earlier entry must be destroyed and its disk entry doomed.
EXPECT_TRUE(cache.disk_cache()->IsDiskEntryDoomed(cache_key));
}
if (i == 0) {
// Consumer gets the response even if cache write failed.
ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
} else {
// Read should lead to a failure being returned.
const int kBufferSize = 5;
scoped_refptr<IOBuffer> buffer =
base::MakeRefCounted<IOBuffer>(kBufferSize);
ReleaseBufferCompletionCallback cb(buffer.get());
c->result = c->trans->Read(buffer.get(), kBufferSize, cb.callback());
EXPECT_EQ(ERR_CACHE_WRITE_FAILURE, cb.GetResult(c->result));
}
}
}
// This is a test for http://code.google.com/p/chromium/issues/detail?id=4769.
// If cancelling a request is racing with another request for the same resource
// finishing, we have to make sure that we remove both transactions from the
// entry.
TEST_F(HttpCacheTest, SimpleGET_RacingReaders) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
MockHttpRequest reader_request(kSimpleGET_Transaction);
reader_request.load_flags = LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 5;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
Context* c = context_list[i].get();
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
MockHttpRequest* this_request = &request;
if (i == 1 || i == 2)
this_request = &reader_request;
c->result = c->trans->Start(this_request, c->callback.callback(),
NetLogWithSource());
}
// Allow all requests to move from the Create queue to the active entry.
base::RunLoop().RunUntilIdle();
// The first request should be a writer at this point, and the subsequent
// requests should be pending.
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
Context* c = context_list[0].get();
ASSERT_THAT(c->result, IsError(ERR_IO_PENDING));
c->result = c->callback.WaitForResult();
ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
// Now all transactions should be waiting for read to be invoked. Two readers
// are because of the load flags and remaining two transactions were converted
// to readers after skipping validation. Note that the remaining two went on
// to process the headers in parallel with readers present on the entry.
EXPECT_EQ(LOAD_STATE_IDLE, context_list[2]->trans->GetLoadState());
EXPECT_EQ(LOAD_STATE_IDLE, context_list[3]->trans->GetLoadState());
c = context_list[1].get();
ASSERT_THAT(c->result, IsError(ERR_IO_PENDING));
c->result = c->callback.WaitForResult();
if (c->result == OK)
ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
// At this point we have one reader, two pending transactions and a task on
// the queue to move to the next transaction. Now we cancel the request that
// is the current reader, and expect the queued task to be able to start the
// next request.
c = context_list[2].get();
c->trans.reset();
for (int i = 3; i < kNumTransactions; ++i) {
c = context_list[i].get();
if (c->result == ERR_IO_PENDING)
c->result = c->callback.WaitForResult();
if (c->result == OK)
ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
}
// We should not have had to re-open the disk entry.
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Tests that we can doom an entry with pending transactions and delete one of
// the pending transactions before the first one completes.
// See http://code.google.com/p/chromium/issues/detail?id=25588
TEST_F(HttpCacheTest, SimpleGET_DoomWithPending) {
// We need simultaneous doomed / not_doomed entries so let's use a real cache.
MockHttpCache cache(HttpCache::DefaultBackend::InMemory(1024 * 1024));
MockHttpRequest request(kSimpleGET_Transaction);
MockHttpRequest writer_request(kSimpleGET_Transaction);
writer_request.load_flags = LOAD_BYPASS_CACHE;
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 4;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
Context* c = context_list[i].get();
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
MockHttpRequest* this_request = &request;
if (i == 3)
this_request = &writer_request;
c->result = c->trans->Start(this_request, c->callback.callback(),
NetLogWithSource());
}
base::RunLoop().RunUntilIdle();
// The first request should be a writer at this point, and the two subsequent
// requests should be pending. The last request doomed the first entry.
EXPECT_EQ(2, cache.network_layer()->transaction_count());
// Cancel the second transaction. Note that this and the 3rd transactions
// would have completed their headers phase and would be waiting in the
// done_headers_queue when the 2nd transaction is cancelled.
context_list[1].reset();
for (int i = 0; i < kNumTransactions; ++i) {
if (i == 1)
continue;
Context* c = context_list[i].get();
ASSERT_THAT(c->result, IsError(ERR_IO_PENDING));
c->result = c->callback.WaitForResult();
ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
}
}
TEST_F(HttpCacheTest, DoomDoesNotSetHints) {
// Test that a doomed writer doesn't set in-memory index hints.
MockHttpCache cache;
cache.disk_cache()->set_support_in_memory_entry_data(true);
// Request 1 is a normal one to a no-cache/no-etag resource, to potentially
// set a "this is unvalidatable" hint in the cache. We also need it to
// actually write out to the doomed entry after request 2 does its thing,
// so its transaction is paused.
MockTransaction no_cache_transaction(kSimpleGET_Transaction);
no_cache_transaction.response_headers = "Cache-Control: no-cache\n";
AddMockTransaction(&no_cache_transaction);
MockHttpRequest request1(no_cache_transaction);
Context c1;
c1.result = cache.CreateTransaction(&c1.trans);
ASSERT_THAT(c1.result, IsOk());
c1.trans->SetBeforeNetworkStartCallback(
base::BindOnce([](bool* defer) { *defer = true; }));
c1.result =
c1.trans->Start(&request1, c1.callback.callback(), NetLogWithSource());
ASSERT_THAT(c1.result, IsError(ERR_IO_PENDING));
// It starts, copies over headers info, but doesn't get to proceed.
base::RunLoop().RunUntilIdle();
RemoveMockTransaction(&no_cache_transaction);
// Request 2 sets LOAD_BYPASS_CACHE to force the first one to be doomed ---
// it'll want to be a writer.
MockHttpRequest request2(kSimpleGET_Transaction);
request2.load_flags = LOAD_BYPASS_CACHE;
Context c2;
c2.result = cache.CreateTransaction(&c2.trans);
ASSERT_THAT(c2.result, IsOk());
c2.result =
c2.trans->Start(&request2, c2.callback.callback(), NetLogWithSource());
ASSERT_THAT(c2.result, IsError(ERR_IO_PENDING));
// Run Request2, then let the first one wrap up.
base::RunLoop().RunUntilIdle();
c2.callback.WaitForResult();
ReadAndVerifyTransaction(c2.trans.get(), kSimpleGET_Transaction);
c1.trans->ResumeNetworkStart();
c1.callback.WaitForResult();
ReadAndVerifyTransaction(c1.trans.get(), no_cache_transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
// Request 3 tries to read from cache, and it should successfully do so. It's
// run after the previous two transactions finish so it doesn't try to
// cooperate with them, and is entirely driven by the state of the cache.
MockHttpRequest request3(kSimpleGET_Transaction);
Context context3;
context3.result = cache.CreateTransaction(&context3.trans);
ASSERT_THAT(context3.result, IsOk());
context3.result = context3.trans->Start(
&request3, context3.callback.callback(), NetLogWithSource());
base::RunLoop().RunUntilIdle();
ASSERT_THAT(context3.result, IsError(ERR_IO_PENDING));
context3.result = context3.callback.WaitForResult();
ReadAndVerifyTransaction(context3.trans.get(), kSimpleGET_Transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// This is a test for http://code.google.com/p/chromium/issues/detail?id=4731.
// We may attempt to delete an entry synchronously with the act of adding a new
// transaction to said entry.
TEST_F(HttpCacheTest, FastNoStoreGET_DoneWithPending) {
MockHttpCache cache;
// The headers will be served right from the call to Start() the request.
MockHttpRequest request(kFastNoStoreGET_Transaction);
FastTransactionServer request_handler;
AddMockTransaction(&kFastNoStoreGET_Transaction);
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 3;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
Context* c = context_list[i].get();
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
c->result =
c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
}
// Allow all requests to move from the Create queue to the active entry.
base::RunLoop().RunUntilIdle();
// The first request should be a writer at this point, and the subsequent
// requests should have completed validation. Since the validation does not
// result in a match, a new entry would be created.
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(3, cache.disk_cache()->create_count());
// Now, make sure that the second request asks for the entry not to be stored.
request_handler.set_no_store(true);
for (int i = 0; i < kNumTransactions; ++i) {
Context* c = context_list[i].get();
if (c->result == ERR_IO_PENDING)
c->result = c->callback.WaitForResult();
ReadAndVerifyTransaction(c->trans.get(), kFastNoStoreGET_Transaction);
context_list[i].reset();
}
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(3, cache.disk_cache()->create_count());
RemoveMockTransaction(&kFastNoStoreGET_Transaction);
}
TEST_F(HttpCacheTest, SimpleGET_ManyWriters_CancelFirst) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 2;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(std::make_unique<Context>());
Context* c = context_list[i].get();
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
c->result =
c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
}
// Allow all requests to move from the Create queue to the active entry.
// All would have been added to writers.
base::RunLoop().RunUntilIdle();
std::string cache_key =
*cache.http_cache()->GenerateCacheKeyForRequest(&request);
EXPECT_EQ(kNumTransactions, cache.GetCountWriterTransactions(cache_key));
// The second transaction skipped validation, thus only one network
// transaction is created.
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
for (int i = 0; i < kNumTransactions; ++i) {
Context* c = context_list[i].get();
if (c->result == ERR_IO_PENDING)
c->result = c->callback.WaitForResult();
// Destroy only the first transaction.
// This should not impact the other writer transaction and the network
// transaction will continue to be used by that transaction.
if (i == 0) {
context_list[i].reset();
}
}
// Complete the rest of the transactions.
for (int i = 1; i < kNumTransactions; ++i) {
Context* c = context_list[i].get();
ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
}
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Tests that we can cancel requests that are queued waiting to open the disk
// cache entry.
TEST_F(HttpCacheTest, SimpleGET_ManyWriters_CancelCreate) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 5;
for (int i = 0; i < kNumTransactions; i++) {
context_list.push_back(std::make_unique<Context>());
Context* c = context_list[i].get();
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
c->result =
c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
}
// The first request should be creating the disk cache entry and the others
// should be pending.
EXPECT_EQ(0, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Cancel a request from the pending queue.
context_list[3].reset();
// Cancel the request that is creating the entry. This will force the pending
// operations to restart.
context_list[0].reset();
// Complete the rest of the transactions.
for (int i = 1; i < kNumTransactions; i++) {
Context* c = context_list[i].get();
if (c) {
c->result = c->callback.GetResult(c->result);
ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
}
}
// We should have had to re-create the disk entry.
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests that we can cancel a single request to open a disk cache entry.
TEST_F(HttpCacheTest, SimpleGET_CancelCreate) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
auto c = std::make_unique<Context>();
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
c->result =
c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
EXPECT_THAT(c->result, IsError(ERR_IO_PENDING));
// Release the reference that the mock disk cache keeps for this entry, so
// that we test that the http cache handles the cancellation correctly.
cache.disk_cache()->ReleaseAll();
c.reset();
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Tests that we delete/create entries even if multiple requests are queued.
TEST_F(HttpCacheTest, SimpleGET_ManyWriters_BypassCache) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
request.load_flags = LOAD_BYPASS_CACHE;
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 5;
for (int i = 0; i < kNumTransactions; i++) {
context_list.push_back(std::make_unique<Context>());
Context* c = context_list[i].get();
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
c->result =
c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
}
// The first request should be deleting the disk cache entry and the others
// should be pending.
EXPECT_EQ(0, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(0, cache.disk_cache()->create_count());
// Complete the transactions.
for (int i = 0; i < kNumTransactions; i++) {
Context* c = context_list[i].get();
c->result = c->callback.GetResult(c->result);
ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
}
// We should have had to re-create the disk entry multiple times.
EXPECT_EQ(5, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(5, cache.disk_cache()->create_count());
}
// Tests that a (simulated) timeout allows transactions waiting on the cache
// lock to continue.
TEST_F(HttpCacheTest, SimpleGET_WriterTimeout) {
MockHttpCache cache;
cache.SimulateCacheLockTimeout();
MockHttpRequest request(kSimpleGET_Transaction);
Context c1, c2;
ASSERT_THAT(cache.CreateTransaction(&c1.trans), IsOk());
ASSERT_EQ(ERR_IO_PENDING, c1.trans->Start(&request, c1.callback.callback(),
NetLogWithSource()));
ASSERT_THAT(cache.CreateTransaction(&c2.trans), IsOk());
ASSERT_EQ(ERR_IO_PENDING, c2.trans->Start(&request, c2.callback.callback(),
NetLogWithSource()));
// The second request is queued after the first one.
c2.callback.WaitForResult();
ReadAndVerifyTransaction(c2.trans.get(), kSimpleGET_Transaction);
// Complete the first transaction.
c1.callback.WaitForResult();
ReadAndVerifyTransaction(c1.trans.get(), kSimpleGET_Transaction);
}
// Tests that a (simulated) timeout allows transactions waiting on the cache
// lock to continue but read only transactions to error out.
TEST_F(HttpCacheTest, SimpleGET_WriterTimeoutReadOnlyError) {
MockHttpCache cache;
// Simulate timeout.
cache.SimulateCacheLockTimeout();
MockHttpRequest request(kSimpleGET_Transaction);
Context c1, c2;
ASSERT_THAT(cache.CreateTransaction(&c1.trans), IsOk());
ASSERT_EQ(ERR_IO_PENDING, c1.trans->Start(&request, c1.callback.callback(),
NetLogWithSource()));
request.load_flags = LOAD_ONLY_FROM_CACHE;
ASSERT_THAT(cache.CreateTransaction(&c2.trans), IsOk());
ASSERT_EQ(ERR_IO_PENDING, c2.trans->Start(&request, c2.callback.callback(),
NetLogWithSource()));
// The second request is queued after the first one.
int res = c2.callback.WaitForResult();
ASSERT_EQ(ERR_CACHE_MISS, res);
// Complete the first transaction.
c1.callback.WaitForResult();
ReadAndVerifyTransaction(c1.trans.get(), kSimpleGET_Transaction);
}
TEST_F(HttpCacheTest, SimpleGET_AbandonedCacheRead) {
MockHttpCache cache;
// write to the cache
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
MockHttpRequest request(kSimpleGET_Transaction);
TestCompletionCallback callback;
std::unique_ptr<HttpTransaction> trans;
ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
if (rv == ERR_IO_PENDING)
rv = callback.WaitForResult();
ASSERT_THAT(rv, IsOk());
scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(256);
rv = trans->Read(buf.get(), 256, callback.callback());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
// Test that destroying the transaction while it is reading from the cache
// works properly.
trans.reset();
// Make sure we pump any pending events, which should include a call to
// HttpCache::Transaction::OnCacheReadCompleted.
base::RunLoop().RunUntilIdle();
}
// Tests that we can delete the HttpCache and deal with queued transactions
// ("waiting for the backend" as opposed to Active or Doomed entries).
TEST_F(HttpCacheTest, SimpleGET_ManyWriters_DeleteCache) {
auto cache = std::make_unique<MockHttpCache>(
std::make_unique<MockBackendNoCbFactory>());
MockHttpRequest request(kSimpleGET_Transaction);
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 5;
for (int i = 0; i < kNumTransactions; i++) {
context_list.push_back(std::make_unique<Context>());
Context* c = context_list[i].get();
c->result = cache->CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
c->result =
c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
}
// The first request should be creating the disk cache entry and the others
// should be pending.
EXPECT_EQ(0, cache->network_layer()->transaction_count());
EXPECT_EQ(0, cache->disk_cache()->open_count());
EXPECT_EQ(0, cache->disk_cache()->create_count());
cache.reset();
}
// Tests that we queue requests when initializing the backend.
TEST_F(HttpCacheTest, SimpleGET_WaitForBackend) {
auto factory = std::make_unique<MockBlockingBackendFactory>();
MockBlockingBackendFactory* factory_ptr = factory.get();
MockHttpCache cache(std::move(factory));
MockHttpRequest request0(kSimpleGET_Transaction);
MockHttpRequest request1(kTypicalGET_Transaction);
MockHttpRequest request2(kETagGET_Transaction);
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 3;
for (int i = 0; i < kNumTransactions; i++) {
context_list.push_back(std::make_unique<Context>());
Context* c = context_list[i].get();
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
}
context_list[0]->result = context_list[0]->trans->Start(
&request0, context_list[0]->callback.callback(), NetLogWithSource());
context_list[1]->result = context_list[1]->trans->Start(
&request1, context_list[1]->callback.callback(), NetLogWithSource());
context_list[2]->result = context_list[2]->trans->Start(
&request2, context_list[2]->callback.callback(), NetLogWithSource());
// Just to make sure that everything is still pending.
base::RunLoop().RunUntilIdle();
// The first request should be creating the disk cache.
EXPECT_FALSE(context_list[0]->callback.have_result());
factory_ptr->FinishCreation();
base::RunLoop().RunUntilIdle();
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(3, cache.disk_cache()->create_count());
for (int i = 0; i < kNumTransactions; ++i) {
EXPECT_TRUE(context_list[i]->callback.have_result());
context_list[i].reset();
}
}
// Tests that we can cancel requests that are queued waiting for the backend
// to be initialized.
TEST_F(HttpCacheTest, SimpleGET_WaitForBackend_CancelCreate) {
auto factory = std::make_unique<MockBlockingBackendFactory>();
MockBlockingBackendFactory* factory_ptr = factory.get();
MockHttpCache cache(std::move(factory));
MockHttpRequest request0(kSimpleGET_Transaction);
MockHttpRequest request1(kTypicalGET_Transaction);
MockHttpRequest request2(kETagGET_Transaction);
std::vector<std::unique_ptr<Context>> context_list;
const int kNumTransactions = 3;
for (int i = 0; i < kNumTransactions; i++) {
context_list.push_back(std::make_unique<Context>());
Context* c = context_list[i].get();
c->result = cache.CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
}
context_list[0]->result = context_list[0]->trans->Start(
&request0, context_list[0]->callback.callback(), NetLogWithSource());
context_list[1]->result = context_list[1]->trans->Start(
&request1, context_list[1]->callback.callback(), NetLogWithSource());
context_list[2]->result = context_list[2]->trans->Start(
&request2, context_list[2]->callback.callback(), NetLogWithSource());
// Just to make sure that everything is still pending.
base::RunLoop().RunUntilIdle();
// The first request should be creating the disk cache.
EXPECT_FALSE(context_list[0]->callback.have_result());
// Cancel a request from the pending queue.
context_list[1].reset();
// Cancel the request that is creating the entry.
context_list[0].reset();
// Complete the last transaction.
factory_ptr->FinishCreation();
context_list[2]->result =
context_list[2]->callback.GetResult(context_list[2]->result);
ReadAndVerifyTransaction(context_list[2]->trans.get(), kETagGET_Transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Tests that we can delete the HttpCache while creating the backend.
TEST_F(HttpCacheTest, DeleteCacheWaitingForBackend) {
auto factory = std::make_unique<MockBlockingBackendFactory>();
MockBlockingBackendFactory* factory_ptr = factory.get();
auto cache = std::make_unique<MockHttpCache>(std::move(factory));
MockHttpRequest request(kSimpleGET_Transaction);
auto c = std::make_unique<Context>();
c->result = cache->CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
// Just to make sure that everything is still pending.
base::RunLoop().RunUntilIdle();
// The request should be creating the disk cache.
EXPECT_FALSE(c->callback.have_result());
// Manually arrange for completion to happen after ~HttpCache.
// This can't be done via FinishCreation() since that's in `factory`, and
// that's owned by `cache`.
disk_cache::BackendResultCallback callback = factory_ptr->ReleaseCallback();
cache.reset();
base::RunLoop().RunUntilIdle();
// Simulate the backend completion callback running now the HttpCache is gone.
std::move(callback).Run(disk_cache::BackendResult::MakeError(ERR_ABORTED));
}
// Tests that we can delete the cache while creating the backend, from within
// one of the callbacks.
TEST_F(HttpCacheTest, DeleteCacheWaitingForBackend2) {
auto factory = std::make_unique<MockBlockingBackendFactory>();
MockBlockingBackendFactory* factory_ptr = factory.get();
auto cache = std::make_unique<MockHttpCache>(std::move(factory));
auto* cache_ptr = cache.get();
DeleteCacheCompletionCallback cb(std::move(cache));
disk_cache::Backend* backend;
int rv = cache_ptr->http_cache()->GetBackend(&backend, cb.callback());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
// Now let's queue a regular transaction
MockHttpRequest request(kSimpleGET_Transaction);
auto c = std::make_unique<Context>();
c->result = cache_ptr->CreateTransaction(&c->trans);
ASSERT_THAT(c->result, IsOk());
c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
// And another direct backend request.
TestCompletionCallback cb2;
rv = cache_ptr->http_cache()->GetBackend(&backend, cb2.callback());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
// Just to make sure that everything is still pending.
base::RunLoop().RunUntilIdle();
// The request should be queued.
EXPECT_FALSE(c->callback.have_result());
// Generate the callback.
factory_ptr->FinishCreation();
rv = cb.WaitForResult();
// The cache should be gone by now.
base::RunLoop().RunUntilIdle();
EXPECT_THAT(c->callback.GetResult(c->result), IsOk());
EXPECT_FALSE(cb2.have_result());
}
TEST_F(HttpCacheTest, TypicalGET_ConditionalRequest) {
MockHttpCache cache;
// write to the cache
RunTransactionTest(cache.http_cache(), kTypicalGET_Transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Get the same URL again, but this time we expect it to result
// in a conditional request.
LoadTimingInfo load_timing_info;
RunTransactionTestAndGetTiming(cache.http_cache(), kTypicalGET_Transaction,
NetLogWithSource::Make(NetLogSourceType::NONE),
&load_timing_info);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
TestLoadTimingNetworkRequest(load_timing_info);
}
static void ETagGet_ConditionalRequest_Handler(const HttpRequestInfo* request,
std::string* response_status,
std::string* response_headers,
std::string* response_data) {
EXPECT_TRUE(
request->extra_headers.HasHeader(HttpRequestHeaders::kIfNoneMatch));
response_status->assign("HTTP/1.1 304 Not Modified");
response_headers->assign(kETagGET_Transaction.response_headers);
response_data->clear();
}
TEST_F(HttpCacheTest, ETagGET_ConditionalRequest_304) {
MockHttpCache cache;
ScopedMockTransaction transaction(kETagGET_Transaction);
// write to the cache
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Get the same URL again, but this time we expect it to result
// in a conditional request.
transaction.load_flags = LOAD_VALIDATE_CACHE;
transaction.handler = ETagGet_ConditionalRequest_Handler;
LoadTimingInfo load_timing_info;
IPEndPoint remote_endpoint;
RunTransactionTestAndGetTimingAndConnectedSocketAddress(
cache.http_cache(), transaction,
NetLogWithSource::Make(NetLogSourceType::NONE), &load_timing_info,
&remote_endpoint);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
TestLoadTimingNetworkRequest(load_timing_info);
EXPECT_FALSE(remote_endpoint.address().empty());
}
class RevalidationServer {
public:
RevalidationServer() {
s_etag_used_ = false;
s_last_modified_used_ = false;
}
bool EtagUsed() { return s_etag_used_; }
bool LastModifiedUsed() { return s_last_modified_used_; }
static void Handler(const HttpRequestInfo* request,
std::string* response_status,
std::string* response_headers,
std::string* response_data);
private:
static bool s_etag_used_;
static bool s_last_modified_used_;
};
bool RevalidationServer::s_etag_used_ = false;
bool RevalidationServer::s_last_modified_used_ = false;
void RevalidationServer::Handler(const HttpRequestInfo* request,
std::string* response_status,
std::string* response_headers,
std::string* response_data) {
if (request->extra_headers.HasHeader(HttpRequestHeaders::kIfNoneMatch))
s_etag_used_ = true;
if (request->extra_headers.HasHeader(HttpRequestHeaders::kIfModifiedSince)) {
s_last_modified_used_ = true;
}
if (s_etag_used_ || s_last_modified_used_) {
response_status->assign("HTTP/1.1 304 Not Modified");
response_headers->assign(kTypicalGET_Transaction.response_headers);
response_data->clear();
} else {
response_status->assign(kTypicalGET_Transaction.status);
response_headers->assign(kTypicalGET_Transaction.response_headers);
response_data->assign(kTypicalGET_Transaction.data);
}
}
// Tests revalidation after a vary match.
TEST_F(HttpCacheTest, GET_ValidateCache_VaryMatch) {
MockHttpCache cache;
// Write to the cache.
MockTransaction transaction(kTypicalGET_Transaction);
transaction.request_headers = "Foo: bar\r\n";
transaction.response_headers =
"Date: Wed, 28 Nov 2007 09:40:09 GMT\n"
"Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
"Etag: \"foopy\"\n"
"Cache-Control: max-age=0\n"
"Vary: Foo\n";
AddMockTransaction(&transaction);
RunTransactionTest(cache.http_cache(), transaction);
// Read from the cache.
RevalidationServer server;
transaction.handler = server.Handler;
LoadTimingInfo load_timing_info;
RunTransactionTestAndGetTiming(cache.http_cache(), transaction,
NetLogWithSource::Make(NetLogSourceType::NONE),
&load_timing_info);
EXPECT_TRUE(server.EtagUsed());
EXPECT_TRUE(server.LastModifiedUsed());
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
TestLoadTimingNetworkRequest(load_timing_info);
RemoveMockTransaction(&transaction);
}
// Tests revalidation after a vary mismatch if etag is present.
TEST_F(HttpCacheTest, GET_ValidateCache_VaryMismatch) {
MockHttpCache cache;
// Write to the cache.
MockTransaction transaction(kTypicalGET_Transaction);
transaction.request_headers = "Foo: bar\r\n";
transaction.response_headers =
"Date: Wed, 28 Nov 2007 09:40:09 GMT\n"
"Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
"Etag: \"foopy\"\n"
"Cache-Control: max-age=0\n"
"Vary: Foo\n";
AddMockTransaction(&transaction);
RunTransactionTest(cache.http_cache(), transaction);
// Read from the cache and revalidate the entry.
RevalidationServer server;
transaction.handler = server.Handler;
transaction.request_headers = "Foo: none\r\n";
LoadTimingInfo load_timing_info;
RunTransactionTestAndGetTiming(cache.http_cache(), transaction,
NetLogWithSource::Make(NetLogSourceType::NONE),
&load_timing_info);
EXPECT_TRUE(server.EtagUsed());
EXPECT_FALSE(server.LastModifiedUsed());
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
TestLoadTimingNetworkRequest(load_timing_info);
RemoveMockTransaction(&transaction);
}
// Tests revalidation after a vary mismatch due to vary: * if etag is present.
TEST_F(HttpCacheTest, GET_ValidateCache_VaryMismatchStar) {
MockHttpCache cache;
// Write to the cache.
MockTransaction transaction(kTypicalGET_Transaction);
transaction.response_headers =
"Date: Wed, 28 Nov 2007 09:40:09 GMT\n"
"Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
"Etag: \"foopy\"\n"
"Cache-Control: max-age=0\n"
"Vary: *\n";
AddMockTransaction(&transaction);
RunTransactionTest(cache.http_cache(), transaction);
// Read from the cache and revalidate the entry.
RevalidationServer server;
transaction.handler = server.Handler;
LoadTimingInfo load_timing_info;
RunTransactionTestAndGetTiming(cache.http_cache(), transaction,
NetLogWithSource::Make(NetLogSourceType::NONE),
&load_timing_info);
EXPECT_TRUE(server.EtagUsed());
EXPECT_FALSE(server.LastModifiedUsed());
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
TestLoadTimingNetworkRequest(load_timing_info);
RemoveMockTransaction(&transaction);
}
// Tests lack of revalidation after a vary mismatch and no etag.
TEST_F(HttpCacheTest, GET_DontValidateCache_VaryMismatch) {
MockHttpCache cache;
// Write to the cache.
MockTransaction transaction(kTypicalGET_Transaction);
transaction.request_headers = "Foo: bar\r\n";
transaction.response_headers =
"Date: Wed, 28 Nov 2007 09:40:09 GMT\n"
"Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
"Cache-Control: max-age=0\n"
"Vary: Foo\n";
AddMockTransaction(&transaction);
RunTransactionTest(cache.http_cache(), transaction);
// Read from the cache and don't revalidate the entry.
RevalidationServer server;
transaction.handler = server.Handler;
transaction.request_headers = "Foo: none\r\n";
LoadTimingInfo load_timing_info;
RunTransactionTestAndGetTiming(cache.http_cache(), transaction,
NetLogWithSource::Make(NetLogSourceType::NONE),
&load_timing_info);
EXPECT_FALSE(server.EtagUsed());
EXPECT_FALSE(server.LastModifiedUsed());
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
TestLoadTimingNetworkRequest(load_timing_info);
RemoveMockTransaction(&transaction);
}
// Tests that a new vary header provided when revalidating an entry is saved.
TEST_F(HttpCacheTest, GET_ValidateCache_VaryMatch_UpdateVary) {
MockHttpCache cache;
// Write to the cache.
ScopedMockTransaction transaction(kTypicalGET_Transaction);
transaction.request_headers = "Foo: bar\r\n Name: bar\r\n";
transaction.response_headers =
"Etag: \"foopy\"\n"
"Cache-Control: max-age=0\n"
"Vary: Foo\n";
RunTransactionTest(cache.http_cache(), transaction);
// Validate the entry and change the vary field in the response.
transaction.request_headers = "Foo: bar\r\n Name: none\r\n";
transaction.status = "HTTP/1.1 304 Not Modified";
transaction.response_headers =
"Etag: \"foopy\"\n"
"Cache-Control: max-age=3600\n"
"Vary: Name\n";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Make sure that the ActiveEntry is gone.
base::RunLoop().RunUntilIdle();
// Generate a vary mismatch.
transaction.request_headers = "Foo: bar\r\n Name: bar\r\n";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(2, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Tests that new request headers causing a vary mismatch are paired with the
// new response when the server says the old response can be used.
TEST_F(HttpCacheTest, GET_ValidateCache_VaryMismatch_UpdateRequestHeader) {
MockHttpCache cache;
// Write to the cache.
ScopedMockTransaction transaction(kTypicalGET_Transaction);
transaction.request_headers = "Foo: bar\r\n";
transaction.response_headers =
"Etag: \"foopy\"\n"
"Cache-Control: max-age=3600\n"
"Vary: Foo\n";
RunTransactionTest(cache.http_cache(), transaction);
// Vary-mismatch validation receives 304.
transaction.request_headers = "Foo: none\r\n";
transaction.status = "HTTP/1.1 304 Not Modified";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Make sure that the ActiveEntry is gone.
base::RunLoop().RunUntilIdle();
// Generate a vary mismatch.
transaction.request_headers = "Foo: bar\r\n";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(2, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Tests that a 304 without vary headers doesn't delete the previously stored
// vary data after a vary match revalidation.
TEST_F(HttpCacheTest, GET_ValidateCache_VaryMatch_DontDeleteVary) {
MockHttpCache cache;
// Write to the cache.
ScopedMockTransaction transaction(kTypicalGET_Transaction);
transaction.request_headers = "Foo: bar\r\n";
transaction.response_headers =
"Etag: \"foopy\"\n"
"Cache-Control: max-age=0\n"
"Vary: Foo\n";
RunTransactionTest(cache.http_cache(), transaction);
// Validate the entry and remove the vary field in the response.
transaction.status = "HTTP/1.1 304 Not Modified";
transaction.response_headers =
"Etag: \"foopy\"\n"
"Cache-Control: max-age=3600\n";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Make sure that the ActiveEntry is gone.
base::RunLoop().RunUntilIdle();
// Generate a vary mismatch.
transaction.request_headers = "Foo: none\r\n";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(2, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Tests that a 304 without vary headers doesn't delete the previously stored
// vary data after a vary mismatch.
TEST_F(HttpCacheTest, GET_ValidateCache_VaryMismatch_DontDeleteVary) {
MockHttpCache cache;
// Write to the cache.
ScopedMockTransaction transaction(kTypicalGET_Transaction);
transaction.request_headers = "Foo: bar\r\n";
transaction.response_headers =
"Etag: \"foopy\"\n"
"Cache-Control: max-age=3600\n"
"Vary: Foo\n";
RunTransactionTest(cache.http_cache(), transaction);
// Vary-mismatch validation receives 304 and no vary header.
transaction.request_headers = "Foo: none\r\n";
transaction.status = "HTTP/1.1 304 Not Modified";
transaction.response_headers =
"Etag: \"foopy\"\n"
"Cache-Control: max-age=3600\n";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Make sure that the ActiveEntry is gone.
base::RunLoop().RunUntilIdle();
// Generate a vary mismatch.
transaction.request_headers = "Foo: bar\r\n";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(2, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
static void ETagGet_UnconditionalRequest_Handler(const HttpRequestInfo* request,
std::string* response_status,
std::string* response_headers,
std::string* response_data) {
EXPECT_FALSE(
request->extra_headers.HasHeader(HttpRequestHeaders::kIfNoneMatch));
}
TEST_F(HttpCacheTest, ETagGET_Http10) {
MockHttpCache cache;
ScopedMockTransaction transaction(kETagGET_Transaction);
transaction.status = "HTTP/1.0 200 OK";
// Write to the cache.
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Get the same URL again, without generating a conditional request.
transaction.load_flags = LOAD_VALIDATE_CACHE;
transaction.handler = ETagGet_UnconditionalRequest_Handler;
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
TEST_F(HttpCacheTest, ETagGET_Http10_Range) {
MockHttpCache cache;
ScopedMockTransaction transaction(kETagGET_Transaction);
transaction.status = "HTTP/1.0 200 OK";
// Write to the cache.
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Get the same URL again, but use a byte range request.
transaction.load_flags = LOAD_VALIDATE_CACHE;
transaction.handler = ETagGet_UnconditionalRequest_Handler;
transaction.request_headers = "Range: bytes = 5-\r\n";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
static void ETagGet_ConditionalRequest_NoStore_Handler(
const HttpRequestInfo* request,
std::string* response_status,
std::string* response_headers,
std::string* response_data) {
EXPECT_TRUE(
request->extra_headers.HasHeader(HttpRequestHeaders::kIfNoneMatch));
response_status->assign("HTTP/1.1 304 Not Modified");
response_headers->assign("Cache-Control: no-store\n");
response_data->clear();
}
TEST_F(HttpCacheTest, ETagGET_ConditionalRequest_304_NoStore) {
MockHttpCache cache;
ScopedMockTransaction transaction(kETagGET_Transaction);
// Write to the cache.
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Get the same URL again, but this time we expect it to result
// in a conditional request.
transaction.load_flags = LOAD_VALIDATE_CACHE;
transaction.handler = ETagGet_ConditionalRequest_NoStore_Handler;
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
ScopedMockTransaction transaction2(kETagGET_Transaction);
// Write to the cache again. This should create a new entry.
RunTransactionTest(cache.http_cache(), transaction2);
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Helper that does 4 requests using HttpCache:
//
// (1) loads |kUrl| -- expects |net_response_1| to be returned.
// (2) loads |kUrl| from cache only -- expects |net_response_1| to be returned.
// (3) loads |kUrl| using |extra_request_headers| -- expects |net_response_2| to
// be returned.
// (4) loads |kUrl| from cache only -- expects |cached_response_2| to be
// returned.
// The entry will be created once and will be opened for the 3 subsequent
// requests.
static void ConditionalizedRequestUpdatesCacheHelper(
const Response& net_response_1,
const Response& net_response_2,
const Response& cached_response_2,
const char* extra_request_headers) {
MockHttpCache cache;
// The URL we will be requesting.
const char kUrl[] = "http://foobar.com/main.css";
// Junk network response.
static const Response kUnexpectedResponse = {
"HTTP/1.1 500 Unexpected",
"Server: unexpected_header",
"unexpected body"
};
// We will control the network layer's responses for |kUrl| using
// |mock_network_response|.
MockTransaction mock_network_response = {nullptr};
mock_network_response.url = kUrl;
AddMockTransaction(&mock_network_response);
// Request |kUrl| for the first time. It should hit the network and
// receive |kNetResponse1|, which it saves into the HTTP cache.
MockTransaction request = {nullptr};
request.url = kUrl;
request.method = "GET";
request.request_headers = "";
net_response_1.AssignTo(&mock_network_response); // Network mock.
net_response_1.AssignTo(&request); // Expected result.
std::string response_headers;
RunTransactionTestWithResponse(
cache.http_cache(), request, &response_headers);
EXPECT_EQ(net_response_1.status_and_headers(), response_headers);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Request |kUrl| a second time. Now |kNetResponse1| it is in the HTTP
// cache, so we don't hit the network.
request.load_flags = LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
kUnexpectedResponse.AssignTo(&mock_network_response); // Network mock.
net_response_1.AssignTo(&request); // Expected result.
RunTransactionTestWithResponse(
cache.http_cache(), request, &response_headers);
EXPECT_EQ(net_response_1.status_and_headers(), response_headers);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Request |kUrl| yet again, but this time give the request an
// "If-Modified-Since" header. This will cause the request to re-hit the
// network. However now the network response is going to be
// different -- this simulates a change made to the CSS file.
request.request_headers = extra_request_headers;
request.load_flags = LOAD_NORMAL;
net_response_2.AssignTo(&mock_network_response); // Network mock.
net_response_2.AssignTo(&request); // Expected result.
RunTransactionTestWithResponse(
cache.http_cache(), request, &response_headers);
EXPECT_EQ(net_response_2.status_and_headers(), response_headers);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Finally, request |kUrl| again. This request should be serviced from
// the cache. Moreover, the value in the cache should be |kNetResponse2|
// and NOT |kNetResponse1|. The previous step should have replaced the
// value in the cache with the modified response.
request.request_headers = "";
request.load_flags = LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
kUnexpectedResponse.AssignTo(&mock_network_response); // Network mock.
cached_response_2.AssignTo(&request); // Expected result.
RunTransactionTestWithResponse(
cache.http_cache(), request, &response_headers);
EXPECT_EQ(cached_response_2.status_and_headers(), response_headers);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(2, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&mock_network_response);
}
// Check that when an "if-modified-since" header is attached
// to the request, the result still updates the cached entry.
TEST_F(HttpCacheTest, ConditionalizedRequestUpdatesCache1) {
// First network response for |kUrl|.
static const Response kNetResponse1 = {
"HTTP/1.1 200 OK",
"Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
"body1"
};
// Second network response for |kUrl|.
static const Response kNetResponse2 = {
"HTTP/1.1 200 OK",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
"Last-Modified: Fri, 03 Jul 2009 02:14:27 GMT\n",
"body2"
};
const char extra_headers[] =
"If-Modified-Since: Wed, 06 Feb 2008 22:38:21 GMT\r\n";
ConditionalizedRequestUpdatesCacheHelper(
kNetResponse1, kNetResponse2, kNetResponse2, extra_headers);
}
// Check that when an "if-none-match" header is attached
// to the request, the result updates the cached entry.
TEST_F(HttpCacheTest, ConditionalizedRequestUpdatesCache2) {
// First network response for |kUrl|.
static const Response kNetResponse1 = {
"HTTP/1.1 200 OK",
"Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
"Etag: \"ETAG1\"\n"
"Expires: Wed, 7 Sep 2033 21:46:42 GMT\n", // Should never expire.
"body1"
};
// Second network response for |kUrl|.
static const Response kNetResponse2 = {
"HTTP/1.1 200 OK",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
"Etag: \"ETAG2\"\n"
"Expires: Wed, 7 Sep 2033 21:46:42 GMT\n", // Should never expire.
"body2"
};
const char extra_headers[] = "If-None-Match: \"ETAG1\"\r\n";
ConditionalizedRequestUpdatesCacheHelper(
kNetResponse1, kNetResponse2, kNetResponse2, extra_headers);
}
// Check that when an "if-modified-since" header is attached
// to a request, the 304 (not modified result) result updates the cached
// headers, and the 304 response is returned rather than the cached response.
TEST_F(HttpCacheTest, ConditionalizedRequestUpdatesCache3) {
// First network response for |kUrl|.
static const Response kNetResponse1 = {
"HTTP/1.1 200 OK",
"Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
"Server: server1\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
"body1"
};
// Second network response for |kUrl|.
static const Response kNetResponse2 = {
"HTTP/1.1 304 Not Modified",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
"Server: server2\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
""
};
static const Response kCachedResponse2 = {
"HTTP/1.1 200 OK",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
"Server: server2\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
"body1"
};
const char extra_headers[] =
"If-Modified-Since: Wed, 06 Feb 2008 22:38:21 GMT\r\n";
ConditionalizedRequestUpdatesCacheHelper(
kNetResponse1, kNetResponse2, kCachedResponse2, extra_headers);
}
// Test that when doing an externally conditionalized if-modified-since
// and there is no corresponding cache entry, a new cache entry is NOT
// created (304 response).
TEST_F(HttpCacheTest, ConditionalizedRequestUpdatesCache4) {
MockHttpCache cache;
const char kUrl[] = "http://foobar.com/main.css";
static const Response kNetResponse = {
"HTTP/1.1 304 Not Modified",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
""
};
const char kExtraRequestHeaders[] =
"If-Modified-Since: Wed, 06 Feb 2008 22:38:21 GMT\r\n";
// We will control the network layer's responses for |kUrl| using
// |mock_network_response|.
MockTransaction mock_network_response = {nullptr};
mock_network_response.url = kUrl;
AddMockTransaction(&mock_network_response);
MockTransaction request = {nullptr};
request.url = kUrl;
request.method = "GET";
request.request_headers = kExtraRequestHeaders;
kNetResponse.AssignTo(&mock_network_response); // Network mock.
kNetResponse.AssignTo(&request); // Expected result.
std::string response_headers;
RunTransactionTestWithResponse(
cache.http_cache(), request, &response_headers);
EXPECT_EQ(kNetResponse.status_and_headers(), response_headers);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(0, cache.disk_cache()->create_count());
RemoveMockTransaction(&mock_network_response);
}
// Test that when doing an externally conditionalized if-modified-since
// and there is no corresponding cache entry, a new cache entry is NOT
// created (200 response).
TEST_F(HttpCacheTest, ConditionalizedRequestUpdatesCache5) {
MockHttpCache cache;
const char kUrl[] = "http://foobar.com/main.css";
static const Response kNetResponse = {
"HTTP/1.1 200 OK",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
"foobar!!!"
};
const char kExtraRequestHeaders[] =
"If-Modified-Since: Wed, 06 Feb 2008 22:38:21 GMT\r\n";
// We will control the network layer's responses for |kUrl| using
// |mock_network_response|.
MockTransaction mock_network_response = {nullptr};
mock_network_response.url = kUrl;
AddMockTransaction(&mock_network_response);
MockTransaction request = {nullptr};
request.url = kUrl;
request.method = "GET";
request.request_headers = kExtraRequestHeaders;
kNetResponse.AssignTo(&mock_network_response); // Network mock.
kNetResponse.AssignTo(&request); // Expected result.
std::string response_headers;
RunTransactionTestWithResponse(
cache.http_cache(), request, &response_headers);
EXPECT_EQ(kNetResponse.status_and_headers(), response_headers);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(0, cache.disk_cache()->create_count());
RemoveMockTransaction(&mock_network_response);
}
// Test that when doing an externally conditionalized if-modified-since
// if the date does not match the cache entry's last-modified date,
// then we do NOT use the response (304) to update the cache.
// (the if-modified-since date is 2 days AFTER the cache's modification date).
TEST_F(HttpCacheTest, ConditionalizedRequestUpdatesCache6) {
static const Response kNetResponse1 = {
"HTTP/1.1 200 OK",
"Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
"Server: server1\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
"body1"
};
// Second network response for |kUrl|.
static const Response kNetResponse2 = {
"HTTP/1.1 304 Not Modified",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
"Server: server2\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
""
};
// This is two days in the future from the original response's last-modified
// date!
const char kExtraRequestHeaders[] =
"If-Modified-Since: Fri, 08 Feb 2008 22:38:21 GMT\r\n";
ConditionalizedRequestUpdatesCacheHelper(
kNetResponse1, kNetResponse2, kNetResponse1, kExtraRequestHeaders);
}
// Test that when doing an externally conditionalized if-none-match
// if the etag does not match the cache entry's etag, then we do not use the
// response (304) to update the cache.
TEST_F(HttpCacheTest, ConditionalizedRequestUpdatesCache7) {
static const Response kNetResponse1 = {
"HTTP/1.1 200 OK",
"Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
"Etag: \"Foo1\"\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
"body1"
};
// Second network response for |kUrl|.
static const Response kNetResponse2 = {
"HTTP/1.1 304 Not Modified",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
"Etag: \"Foo2\"\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
""
};
// Different etag from original response.
const char kExtraRequestHeaders[] = "If-None-Match: \"Foo2\"\r\n";
ConditionalizedRequestUpdatesCacheHelper(
kNetResponse1, kNetResponse2, kNetResponse1, kExtraRequestHeaders);
}
// Test that doing an externally conditionalized request with both if-none-match
// and if-modified-since updates the cache.
TEST_F(HttpCacheTest, ConditionalizedRequestUpdatesCache8) {
static const Response kNetResponse1 = {
"HTTP/1.1 200 OK",
"Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
"Etag: \"Foo1\"\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
"body1"
};
// Second network response for |kUrl|.
static const Response kNetResponse2 = {
"HTTP/1.1 200 OK",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
"Etag: \"Foo2\"\n"
"Last-Modified: Fri, 03 Jul 2009 02:14:27 GMT\n",
"body2"
};
const char kExtraRequestHeaders[] =
"If-Modified-Since: Wed, 06 Feb 2008 22:38:21 GMT\r\n"
"If-None-Match: \"Foo1\"\r\n";
ConditionalizedRequestUpdatesCacheHelper(
kNetResponse1, kNetResponse2, kNetResponse2, kExtraRequestHeaders);
}
// Test that doing an externally conditionalized request with both if-none-match
// and if-modified-since does not update the cache with only one match.
TEST_F(HttpCacheTest, ConditionalizedRequestUpdatesCache9) {
static const Response kNetResponse1 = {
"HTTP/1.1 200 OK",
"Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
"Etag: \"Foo1\"\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
"body1"
};
// Second network response for |kUrl|.
static const Response kNetResponse2 = {
"HTTP/1.1 200 OK",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
"Etag: \"Foo2\"\n"
"Last-Modified: Fri, 03 Jul 2009 02:14:27 GMT\n",
"body2"
};
// The etag doesn't match what we have stored.
const char kExtraRequestHeaders[] =
"If-Modified-Since: Wed, 06 Feb 2008 22:38:21 GMT\r\n"
"If-None-Match: \"Foo2\"\r\n";
ConditionalizedRequestUpdatesCacheHelper(
kNetResponse1, kNetResponse2, kNetResponse1, kExtraRequestHeaders);
}
// Test that doing an externally conditionalized request with both if-none-match
// and if-modified-since does not update the cache with only one match.
TEST_F(HttpCacheTest, ConditionalizedRequestUpdatesCache10) {
static const Response kNetResponse1 = {
"HTTP/1.1 200 OK",
"Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
"Etag: \"Foo1\"\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
"body1"
};
// Second network response for |kUrl|.
static const Response kNetResponse2 = {
"HTTP/1.1 200 OK",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
"Etag: \"Foo2\"\n"
"Last-Modified: Fri, 03 Jul 2009 02:14:27 GMT\n",
"body2"
};
// The modification date doesn't match what we have stored.
const char kExtraRequestHeaders[] =
"If-Modified-Since: Fri, 08 Feb 2008 22:38:21 GMT\r\n"
"If-None-Match: \"Foo1\"\r\n";
ConditionalizedRequestUpdatesCacheHelper(
kNetResponse1, kNetResponse2, kNetResponse1, kExtraRequestHeaders);
}
TEST_F(HttpCacheTest, UrlContainingHash) {
MockHttpCache cache;
// Do a typical GET request -- should write an entry into our cache.
MockTransaction trans(kTypicalGET_Transaction);
RunTransactionTest(cache.http_cache(), trans);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Request the same URL, but this time with a reference section (hash).
// Since the cache key strips the hash sections, this should be a cache hit.
std::string url_with_hash = std::string(trans.url) + "#multiple#hashes";
trans.url = url_with_hash.c_str();
trans.load_flags = LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
RunTransactionTest(cache.http_cache(), trans);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Tests that we skip the cache for POST requests that do not have an upload
// identifier.
TEST_F(HttpCacheTest, SimplePOST_SkipsCache) {
MockHttpCache cache;
RunTransactionTest(cache.http_cache(), kSimplePOST_Transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(0, cache.disk_cache()->create_count());
}
// Tests POST handling with a disabled cache (no DCHECK).
TEST_F(HttpCacheTest, SimplePOST_DisabledCache) {
MockHttpCache cache;
cache.http_cache()->set_mode(HttpCache::Mode::DISABLE);
RunTransactionTest(cache.http_cache(), kSimplePOST_Transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(0, cache.disk_cache()->create_count());
}
TEST_F(HttpCacheTest, SimplePOST_LoadOnlyFromCache_Miss) {
MockHttpCache cache;
MockTransaction transaction(kSimplePOST_Transaction);
transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
MockHttpRequest request(transaction);
TestCompletionCallback callback;
std::unique_ptr<HttpTransaction> trans;
ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
ASSERT_TRUE(trans.get());
int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
ASSERT_THAT(callback.GetResult(rv), IsError(ERR_CACHE_MISS));
trans.reset();
EXPECT_EQ(0, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(0, cache.disk_cache()->create_count());
}
TEST_F(HttpCacheTest, SimplePOST_LoadOnlyFromCache_Hit) {
MockHttpCache cache;
// Test that we hit the cache for POST requests.
MockTransaction transaction(kSimplePOST_Transaction);
const int64_t kUploadId = 1; // Just a dummy value.
std::vector<std::unique_ptr<UploadElementReader>> element_readers;
element_readers.push_back(
std::make_unique<UploadBytesElementReader>("hello", 5));
ElementsUploadDataStream upload_data_stream(std::move(element_readers),
kUploadId);
MockHttpRequest request(transaction);
request.upload_data_stream = &upload_data_stream;
// Populate the cache.
RunTransactionTestWithRequest(cache.http_cache(), transaction, request,
nullptr);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Load from cache.
request.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
RunTransactionTestWithRequest(cache.http_cache(), transaction, request,
nullptr);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Test that we don't hit the cache for POST requests if there is a byte range.
TEST_F(HttpCacheTest, SimplePOST_WithRanges) {
MockHttpCache cache;
MockTransaction transaction(kSimplePOST_Transaction);
transaction.request_headers = "Range: bytes = 0-4\r\n";
const int64_t kUploadId = 1; // Just a dummy value.
std::vector<std::unique_ptr<UploadElementReader>> element_readers;
element_readers.push_back(
std::make_unique<UploadBytesElementReader>("hello", 5));
ElementsUploadDataStream upload_data_stream(std::move(element_readers),
kUploadId);
MockHttpRequest request(transaction);
request.upload_data_stream = &upload_data_stream;
// Attempt to populate the cache.
RunTransactionTestWithRequest(cache.http_cache(), transaction, request,
nullptr);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(0, cache.disk_cache()->create_count());
}
// Tests that a POST is cached separately from a GET.
TEST_F(HttpCacheTest, SimplePOST_SeparateCache) {
MockHttpCache cache;
std::vector<std::unique_ptr<UploadElementReader>> element_readers;
element_readers.push_back(
std::make_unique<UploadBytesElementReader>("hello", 5));
ElementsUploadDataStream upload_data_stream(std::move(element_readers), 1);
MockTransaction transaction(kSimplePOST_Transaction);
MockHttpRequest req1(transaction);
req1.upload_data_stream = &upload_data_stream;
RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, nullptr);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
transaction.method = "GET";
MockHttpRequest req2(transaction);
RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, nullptr);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests that a successful POST invalidates a previously cached GET.
TEST_F(HttpCacheTest, SimplePOST_Invalidate_205) {
MockHttpCache cache;
MockTransaction transaction(kSimpleGET_Transaction);
AddMockTransaction(&transaction);
MockHttpRequest req1(transaction);
// Attempt to populate the cache.
RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, nullptr);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
std::vector<std::unique_ptr<UploadElementReader>> element_readers;
element_readers.push_back(
std::make_unique<UploadBytesElementReader>("hello", 5));
ElementsUploadDataStream upload_data_stream(std::move(element_readers), 1);
transaction.method = "POST";
transaction.status = "HTTP/1.1 205 No Content";
MockHttpRequest req2(transaction);
req2.upload_data_stream = &upload_data_stream;
RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, nullptr);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, nullptr);
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(3, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests that a successful POST invalidates a previously cached GET,
// with cache split by top-frame origin.
TEST_P(HttpCacheTest_SplitCacheFeatureEnabled,
SimplePOST_Invalidate_205_SplitCache) {
SchemefulSite site_a(GURL("http://a.com"));
SchemefulSite site_b(GURL("http://b.com"));
MockHttpCache cache;
MockTransaction transaction(kSimpleGET_Transaction);
AddMockTransaction(&transaction);
MockHttpRequest req1(transaction);
req1.network_isolation_key = NetworkIsolationKey(site_a, site_a);
req1.network_anonymization_key =
net::NetworkAnonymizationKey::CreateSameSite(site_a);
// Attempt to populate the cache.
RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, nullptr);
// Same for a different origin.
MockHttpRequest req1b(transaction);
req1b.network_isolation_key = NetworkIsolationKey(site_b, site_b);
req1b.network_anonymization_key =
net::NetworkAnonymizationKey::CreateSameSite(site_b);
RunTransactionTestWithRequest(cache.http_cache(), transaction, req1b,
nullptr);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
std::vector<std::unique_ptr<UploadElementReader>> element_readers;
element_readers.push_back(
std::make_unique<UploadBytesElementReader>("hello", 5));
ElementsUploadDataStream upload_data_stream(std::move(element_readers), 1);
transaction.method = "POST";
transaction.status = "HTTP/1.1 205 No Content";
MockHttpRequest req2(transaction);
req2.upload_data_stream = &upload_data_stream;
req2.network_isolation_key = NetworkIsolationKey(site_a, site_a);
req2.network_anonymization_key =
net::NetworkAnonymizationKey::CreateSameSite(site_a);
RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, nullptr);
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(3, cache.disk_cache()->create_count());
// req1b should still be cached, since it has a different top-level frame
// origin.
RunTransactionTestWithRequest(cache.http_cache(), transaction, req1b,
nullptr);
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(3, cache.disk_cache()->create_count());
// req1 should not be cached after the POST.
RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, nullptr);
EXPECT_EQ(4, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(4, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests that a successful POST invalidates a previously cached GET, even when
// there is no upload identifier.
TEST_F(HttpCacheTest, SimplePOST_NoUploadId_Invalidate_205) {
MockHttpCache cache;
MockTransaction transaction(kSimpleGET_Transaction);
AddMockTransaction(&transaction);
MockHttpRequest req1(transaction);
// Attempt to populate the cache.
RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, nullptr);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
std::vector<std::unique_ptr<UploadElementReader>> element_readers;
element_readers.push_back(
std::make_unique<UploadBytesElementReader>("hello", 5));
ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
transaction.method = "POST";
transaction.status = "HTTP/1.1 205 No Content";
MockHttpRequest req2(transaction);
req2.upload_data_stream = &upload_data_stream;
RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, nullptr);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, nullptr);
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests that processing a POST before creating the backend doesn't crash.
TEST_F(HttpCacheTest, SimplePOST_NoUploadId_NoBackend) {
// This will initialize a cache object with NULL backend.
auto factory = std::make_unique<MockBlockingBackendFactory>();
factory->set_fail(true);
factory->FinishCreation();
MockHttpCache cache(std::move(factory));
std::vector<std::unique_ptr<UploadElementReader>> element_readers;
element_readers.push_back(
std::make_unique<UploadBytesElementReader>("hello", 5));
ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
MockTransaction transaction(kSimplePOST_Transaction);
AddMockTransaction(&transaction);
MockHttpRequest req(transaction);
req.upload_data_stream = &upload_data_stream;
RunTransactionTestWithRequest(cache.http_cache(), transaction, req, nullptr);
RemoveMockTransaction(&transaction);
}
// Tests that we don't invalidate entries as a result of a failed POST.
TEST_F(HttpCacheTest, SimplePOST_DontInvalidate_100) {
MockHttpCache cache;
MockTransaction transaction(kSimpleGET_Transaction);
AddMockTransaction(&transaction);
MockHttpRequest req1(transaction);
// Attempt to populate the cache.
RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, nullptr);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
std::vector<std::unique_ptr<UploadElementReader>> element_readers;
element_readers.push_back(
std::make_unique<UploadBytesElementReader>("hello", 5));
ElementsUploadDataStream upload_data_stream(std::move(element_readers), 1);
transaction.method = "POST";
transaction.status = "HTTP/1.1 100 Continue";
MockHttpRequest req2(transaction);
req2.upload_data_stream = &upload_data_stream;
RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, nullptr);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, nullptr);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests that a HEAD request is not cached by itself.
TEST_F(HttpCacheTest, SimpleHEAD_LoadOnlyFromCache_Miss) {
MockHttpCache cache;
MockTransaction transaction(kSimplePOST_Transaction);
AddMockTransaction(&transaction);
transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
transaction.method = "HEAD";
MockHttpRequest request(transaction);
TestCompletionCallback callback;
std::unique_ptr<HttpTransaction> trans;
ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
ASSERT_TRUE(trans.get());
int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
ASSERT_THAT(callback.GetResult(rv), IsError(ERR_CACHE_MISS));
trans.reset();
EXPECT_EQ(0, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(0, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests that a HEAD request is served from a cached GET.
TEST_F(HttpCacheTest, SimpleHEAD_LoadOnlyFromCache_Hit) {
MockHttpCache cache;
MockTransaction transaction(kSimpleGET_Transaction);
AddMockTransaction(&transaction);
// Populate the cache.
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Load from cache.
transaction.method = "HEAD";
transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
transaction.data = "";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests that a read-only request served from the cache preserves CL.
TEST_F(HttpCacheTest, SimpleHEAD_ContentLengthOnHit_Read) {
MockHttpCache cache;
MockTransaction transaction(kSimpleGET_Transaction);
AddMockTransaction(&transaction);
transaction.response_headers = "Content-Length: 42\n";
// Populate the cache.
RunTransactionTest(cache.http_cache(), transaction);
// Load from cache.
transaction.method = "HEAD";
transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
transaction.data = "";
std::string headers;
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
EXPECT_EQ("HTTP/1.1 200 OK\nContent-Length: 42\n", headers);
RemoveMockTransaction(&transaction);
}
// Tests that a read-write request served from the cache preserves CL.
TEST_F(HttpCacheTest, ETagHEAD_ContentLengthOnHit_ReadWrite) {
MockHttpCache cache;
MockTransaction transaction(kETagGET_Transaction);
AddMockTransaction(&transaction);
std::string server_headers(kETagGET_Transaction.response_headers);
server_headers.append("Content-Length: 42\n");
transaction.response_headers = server_headers.data();
// Populate the cache.
RunTransactionTest(cache.http_cache(), transaction);
// Load from cache.
transaction.method = "HEAD";
transaction.data = "";
std::string headers;
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
EXPECT_NE(std::string::npos, headers.find("Content-Length: 42\n"));
RemoveMockTransaction(&transaction);
}
// Tests that a HEAD request that includes byte ranges bypasses the cache.
TEST_F(HttpCacheTest, SimpleHEAD_WithRanges) {
MockHttpCache cache;
MockTransaction transaction(kSimpleGET_Transaction);
AddMockTransaction(&transaction);
// Populate the cache.
RunTransactionTest(cache.http_cache(), transaction);
// Load from cache.
transaction.method = "HEAD";
transaction.request_headers = "Range: bytes = 0-4\r\n";
transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
transaction.start_return_code = ERR_CACHE_MISS;
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests that a HEAD request can be served from a partialy cached resource.
TEST_F(HttpCacheTest, SimpleHEAD_WithCachedRanges) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
// Write to the cache (40-49).
RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
RemoveMockTransaction(&kRangeGET_TransactionOK);
MockTransaction transaction(kSimpleGET_Transaction);
transaction.url = kRangeGET_TransactionOK.url;
transaction.method = "HEAD";
transaction.data = "";
AddMockTransaction(&transaction);
std::string headers;
// Load from cache.
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
EXPECT_NE(std::string::npos, headers.find("HTTP/1.1 200 OK\n"));
EXPECT_NE(std::string::npos, headers.find("Content-Length: 80\n"));
EXPECT_EQ(std::string::npos, headers.find("Content-Range"));
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests that a HEAD request can be served from a truncated resource.
TEST_F(HttpCacheTest, SimpleHEAD_WithTruncatedEntry) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
std::string raw_headers("HTTP/1.1 200 OK\n"
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
"Content-Length: 80\n");
CreateTruncatedEntry(raw_headers, &cache);
RemoveMockTransaction(&kRangeGET_TransactionOK);
MockTransaction transaction(kSimpleGET_Transaction);
transaction.url = kRangeGET_TransactionOK.url;
transaction.method = "HEAD";
transaction.data = "";
AddMockTransaction(&transaction);
std::string headers;
// Load from cache.
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
EXPECT_NE(std::string::npos, headers.find("HTTP/1.1 200 OK\n"));
EXPECT_NE(std::string::npos, headers.find("Content-Length: 80\n"));
EXPECT_EQ(std::string::npos, headers.find("Content-Range"));
EXPECT_EQ(0, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests that a HEAD request updates the cached response.
TEST_F(HttpCacheTest, TypicalHEAD_UpdatesResponse) {
MockHttpCache cache;
MockTransaction transaction(kTypicalGET_Transaction);
AddMockTransaction(&transaction);
// Populate the cache.
RunTransactionTest(cache.http_cache(), transaction);
// Update the cache.
transaction.method = "HEAD";
transaction.response_headers = "Foo: bar\n";
transaction.data = "";
transaction.status = "HTTP/1.1 304 Not Modified\n";
std::string headers;
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
RemoveMockTransaction(&transaction);
EXPECT_NE(std::string::npos, headers.find("HTTP/1.1 200 OK\n"));
EXPECT_EQ(2, cache.network_layer()->transaction_count());
MockTransaction transaction2(kTypicalGET_Transaction);
AddMockTransaction(&transaction2);
// Make sure we are done with the previous transaction.
base::RunLoop().RunUntilIdle();
// Load from the cache.
transaction2.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
RunTransactionTestWithResponse(cache.http_cache(), transaction2, &headers);
EXPECT_NE(std::string::npos, headers.find("Foo: bar\n"));
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(2, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction2);
}
// Tests that an externally conditionalized HEAD request updates the cache.
TEST_F(HttpCacheTest, TypicalHEAD_ConditionalizedRequestUpdatesResponse) {
MockHttpCache cache;
MockTransaction transaction(kTypicalGET_Transaction);
AddMockTransaction(&transaction);
// Populate the cache.
RunTransactionTest(cache.http_cache(), transaction);
// Update the cache.
transaction.method = "HEAD";
transaction.request_headers =
"If-Modified-Since: Wed, 28 Nov 2007 00:40:09 GMT\r\n";
transaction.response_headers = "Foo: bar\n";
transaction.data = "";
transaction.status = "HTTP/1.1 304 Not Modified\n";
std::string headers;
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
RemoveMockTransaction(&transaction);
EXPECT_NE(std::string::npos, headers.find("HTTP/1.1 304 Not Modified\n"));
EXPECT_EQ(2, cache.network_layer()->transaction_count());
MockTransaction transaction2(kTypicalGET_Transaction);
AddMockTransaction(&transaction2);
// Make sure we are done with the previous transaction.
base::RunLoop().RunUntilIdle();
// Load from the cache.
transaction2.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
RunTransactionTestWithResponse(cache.http_cache(), transaction2, &headers);
EXPECT_NE(std::string::npos, headers.find("Foo: bar\n"));
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(2, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction2);
}
// Tests that a HEAD request invalidates an old cached entry.
TEST_F(HttpCacheTest, SimpleHEAD_InvalidatesEntry) {
MockHttpCache cache;
MockTransaction transaction(kTypicalGET_Transaction);
AddMockTransaction(&transaction);
// Populate the cache.
RunTransactionTest(cache.http_cache(), transaction);
// Update the cache.
transaction.method = "HEAD";
transaction.data = "";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
// Load from the cache.
transaction.method = "GET";
transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
transaction.start_return_code = ERR_CACHE_MISS;
RunTransactionTest(cache.http_cache(), transaction);
RemoveMockTransaction(&transaction);
}
// Tests that we do not cache the response of a PUT.
TEST_F(HttpCacheTest, SimplePUT_Miss) {
MockHttpCache cache;
MockTransaction transaction(kSimplePOST_Transaction);
transaction.method = "PUT";
std::vector<std::unique_ptr<UploadElementReader>> element_readers;
element_readers.push_back(
std::make_unique<UploadBytesElementReader>("hello", 5));
ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
MockHttpRequest request(transaction);
request.upload_data_stream = &upload_data_stream;
// Attempt to populate the cache.
RunTransactionTestWithRequest(cache.http_cache(), transaction, request,
nullptr);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(0, cache.disk_cache()->create_count());
}
// Tests that we invalidate entries as a result of a PUT.
TEST_F(HttpCacheTest, SimplePUT_Invalidate) {
MockHttpCache cache;
MockTransaction transaction(kSimpleGET_Transaction);
MockHttpRequest req1(transaction);
// Attempt to populate the cache.
RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, nullptr);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
std::vector<std::unique_ptr<UploadElementReader>> element_readers;
element_readers.push_back(
std::make_unique<UploadBytesElementReader>("hello", 5));
ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
transaction.method = "PUT";
MockHttpRequest req2(transaction);
req2.upload_data_stream = &upload_data_stream;
RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, nullptr);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, nullptr);
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests that we invalidate entries as a result of a PUT.
TEST_F(HttpCacheTest, SimplePUT_Invalidate_305) {
MockHttpCache cache;
MockTransaction transaction(kSimpleGET_Transaction);
AddMockTransaction(&transaction);
MockHttpRequest req1(transaction);
// Attempt to populate the cache.
RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, nullptr);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
std::vector<std::unique_ptr<UploadElementReader>> element_readers;
element_readers.push_back(
std::make_unique<UploadBytesElementReader>("hello", 5));
ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
transaction.method = "PUT";
transaction.status = "HTTP/1.1 305 Use Proxy";
MockHttpRequest req2(transaction);
req2.upload_data_stream = &upload_data_stream;
RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, nullptr);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, nullptr);
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests that we don't invalidate entries as a result of a failed PUT.
TEST_F(HttpCacheTest, SimplePUT_DontInvalidate_404) {
MockHttpCache cache;
MockTransaction transaction(kSimpleGET_Transaction);
AddMockTransaction(&transaction);
MockHttpRequest req1(transaction);
// Attempt to populate the cache.
RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, nullptr);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
std::vector<std::unique_ptr<UploadElementReader>> element_readers;
element_readers.push_back(
std::make_unique<UploadBytesElementReader>("hello", 5));
ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
transaction.method = "PUT";
transaction.status = "HTTP/1.1 404 Not Found";
MockHttpRequest req2(transaction);
req2.upload_data_stream = &upload_data_stream;
RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, nullptr);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, nullptr);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(2, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests that we do not cache the response of a DELETE.
TEST_F(HttpCacheTest, SimpleDELETE_Miss) {
MockHttpCache cache;
MockTransaction transaction(kSimplePOST_Transaction);
transaction.method = "DELETE";
std::vector<std::unique_ptr<UploadElementReader>> element_readers;
element_readers.push_back(
std::make_unique<UploadBytesElementReader>("hello", 5));
ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
MockHttpRequest request(transaction);
request.upload_data_stream = &upload_data_stream;
// Attempt to populate the cache.
RunTransactionTestWithRequest(cache.http_cache(), transaction, request,
nullptr);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(0, cache.disk_cache()->create_count());
}
// Tests that we invalidate entries as a result of a DELETE.
TEST_F(HttpCacheTest, SimpleDELETE_Invalidate) {
MockHttpCache cache;
MockTransaction transaction(kSimpleGET_Transaction);
MockHttpRequest req1(transaction);
// Attempt to populate the cache.
RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, nullptr);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
std::vector<std::unique_ptr<UploadElementReader>> element_readers;
element_readers.push_back(
std::make_unique<UploadBytesElementReader>("hello", 5));
ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
transaction.method = "DELETE";
MockHttpRequest req2(transaction);
req2.upload_data_stream = &upload_data_stream;
RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, nullptr);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, nullptr);
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests that we invalidate entries as a result of a DELETE.
TEST_F(HttpCacheTest, SimpleDELETE_Invalidate_301) {
MockHttpCache cache;
MockTransaction transaction(kSimpleGET_Transaction);
AddMockTransaction(&transaction);
// Attempt to populate the cache.
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
transaction.method = "DELETE";
transaction.status = "HTTP/1.1 301 Moved Permanently ";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
transaction.method = "GET";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests that we don't invalidate entries as a result of a failed DELETE.
TEST_F(HttpCacheTest, SimpleDELETE_DontInvalidate_416) {
MockHttpCache cache;
MockTransaction transaction(kSimpleGET_Transaction);
AddMockTransaction(&transaction);
// Attempt to populate the cache.
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
transaction.method = "DELETE";
transaction.status = "HTTP/1.1 416 Requested Range Not Satisfiable";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
transaction.method = "GET";
transaction.status = "HTTP/1.1 200 OK";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(2, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests that we invalidate entries as a result of a PATCH.
TEST_F(HttpCacheTest, SimplePATCH_Invalidate) {
MockHttpCache cache;
MockTransaction transaction(kSimpleGET_Transaction);
MockHttpRequest req1(transaction);
// Attempt to populate the cache.
RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, nullptr);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
std::vector<std::unique_ptr<UploadElementReader>> element_readers;
element_readers.push_back(
std::make_unique<UploadBytesElementReader>("hello", 5));
ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
transaction.method = "PATCH";
MockHttpRequest req2(transaction);
req2.upload_data_stream = &upload_data_stream;
RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, nullptr);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, nullptr);
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests that we invalidate entries as a result of a PATCH.
TEST_F(HttpCacheTest, SimplePATCH_Invalidate_301) {
MockHttpCache cache;
MockTransaction transaction(kSimpleGET_Transaction);
AddMockTransaction(&transaction);
// Attempt to populate the cache.
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
transaction.method = "PATCH";
transaction.status = "HTTP/1.1 301 Moved Permanently ";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
transaction.method = "GET";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests that we don't invalidate entries as a result of a failed PATCH.
TEST_F(HttpCacheTest, SimplePATCH_DontInvalidate_416) {
MockHttpCache cache;
MockTransaction transaction(kSimpleGET_Transaction);
AddMockTransaction(&transaction);
// Attempt to populate the cache.
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
transaction.method = "PATCH";
transaction.status = "HTTP/1.1 416 Requested Range Not Satisfiable";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
transaction.method = "GET";
transaction.status = "HTTP/1.1 200 OK";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(2, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests that we don't invalidate entries after a failed network transaction.
TEST_F(HttpCacheTest, SimpleGET_DontInvalidateOnFailure) {
MockHttpCache cache;
// Populate the cache.
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
// Fail the network request.
MockTransaction transaction(kSimpleGET_Transaction);
transaction.start_return_code = ERR_FAILED;
transaction.load_flags |= LOAD_VALIDATE_CACHE;
AddMockTransaction(&transaction);
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
RemoveMockTransaction(&transaction);
transaction.load_flags = LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
transaction.start_return_code = OK;
AddMockTransaction(&transaction);
RunTransactionTest(cache.http_cache(), transaction);
// Make sure the transaction didn't reach the network.
EXPECT_EQ(2, cache.network_layer()->transaction_count());
RemoveMockTransaction(&transaction);
}
TEST_F(HttpCacheTest, RangeGET_SkipsCache) {
MockHttpCache cache;
// Test that we skip the cache for range GET requests. Eventually, we will
// want to cache these, but we'll still have cases where skipping the cache
// makes sense, so we want to make sure that it works properly.
RunTransactionTest(cache.http_cache(), kRangeGET_Transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(0, cache.disk_cache()->create_count());
MockTransaction transaction(kSimpleGET_Transaction);
transaction.request_headers = "If-None-Match: foo\r\n";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(0, cache.disk_cache()->create_count());
transaction.request_headers =
"If-Modified-Since: Wed, 28 Nov 2007 00:45:20 GMT\r\n";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(0, cache.disk_cache()->create_count());
}
// Test that we skip the cache for range requests that include a validation
// header.
TEST_F(HttpCacheTest, RangeGET_SkipsCache2) {
MockHttpCache cache;
MockTransaction transaction(kRangeGET_Transaction);
transaction.request_headers = "If-None-Match: foo\r\n"
EXTRA_HEADER
"Range: bytes = 40-49\r\n";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(0, cache.disk_cache()->create_count());
transaction.request_headers =
"If-Modified-Since: Wed, 28 Nov 2007 00:45:20 GMT\r\n"
EXTRA_HEADER
"Range: bytes = 40-49\r\n";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(0, cache.disk_cache()->create_count());
transaction.request_headers = "If-Range: bla\r\n"
EXTRA_HEADER
"Range: bytes = 40-49\r\n";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(0, cache.disk_cache()->create_count());
}
TEST_F(HttpCacheTest, SimpleGET_DoesntLogHeaders) {
MockHttpCache cache;
RecordingNetLogObserver net_log_observer;
RunTransactionTestWithLog(cache.http_cache(), kSimpleGET_Transaction,
NetLogWithSource::Make(NetLogSourceType::NONE));
EXPECT_FALSE(LogContainsEventType(
net_log_observer, NetLogEventType::HTTP_CACHE_CALLER_REQUEST_HEADERS));
}
TEST_F(HttpCacheTest, RangeGET_LogsHeaders) {
MockHttpCache cache;
RecordingNetLogObserver net_log_observer;
RunTransactionTestWithLog(cache.http_cache(), kRangeGET_Transaction,
NetLogWithSource::Make(NetLogSourceType::NONE));
EXPECT_TRUE(LogContainsEventType(
net_log_observer, NetLogEventType::HTTP_CACHE_CALLER_REQUEST_HEADERS));
}
TEST_F(HttpCacheTest, ExternalValidation_LogsHeaders) {
MockHttpCache cache;
RecordingNetLogObserver net_log_observer;
MockTransaction transaction(kSimpleGET_Transaction);
transaction.request_headers = "If-None-Match: foo\r\n" EXTRA_HEADER;
RunTransactionTestWithLog(cache.http_cache(), transaction,
NetLogWithSource::Make(NetLogSourceType::NONE));
EXPECT_TRUE(LogContainsEventType(
net_log_observer, NetLogEventType::HTTP_CACHE_CALLER_REQUEST_HEADERS));
}
TEST_F(HttpCacheTest, SpecialHeaders_LogsHeaders) {
MockHttpCache cache;
RecordingNetLogObserver net_log_observer;
MockTransaction transaction(kSimpleGET_Transaction);
transaction.request_headers = "cache-control: no-cache\r\n" EXTRA_HEADER;
RunTransactionTestWithLog(cache.http_cache(), transaction,
NetLogWithSource::Make(NetLogSourceType::NONE));
EXPECT_TRUE(LogContainsEventType(
net_log_observer, NetLogEventType::HTTP_CACHE_CALLER_REQUEST_HEADERS));
}
// Tests that receiving 206 for a regular request is handled correctly.
TEST_F(HttpCacheTest, GET_Crazy206) {
MockHttpCache cache;
// Write to the cache.
MockTransaction transaction(kRangeGET_TransactionOK);
AddMockTransaction(&transaction);
transaction.request_headers = EXTRA_HEADER;
transaction.handler = nullptr;
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// This should read again from the net.
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests that receiving 416 for a regular request is handled correctly.
TEST_F(HttpCacheTest, GET_Crazy416) {
MockHttpCache cache;
// Write to the cache.
MockTransaction transaction(kSimpleGET_Transaction);
AddMockTransaction(&transaction);
transaction.status = "HTTP/1.1 416 Requested Range Not Satisfiable";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests that we don't store partial responses that can't be validated.
TEST_F(HttpCacheTest, RangeGET_NoStrongValidators) {
MockHttpCache cache;
std::string headers;
// Attempt to write to the cache (40-49).
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
transaction.response_headers = "Content-Length: 10\n"
"Cache-Control: max-age=3600\n"
"ETag: w/\"foo\"\n";
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Now verify that there's no cached data.
RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
&headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests failures to conditionalize byte range requests.
TEST_F(HttpCacheTest, RangeGET_NoConditionalization) {
MockHttpCache cache;
cache.FailConditionalizations();
std::string headers;
// Write to the cache (40-49).
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
transaction.response_headers = "Content-Length: 10\n"
"ETag: \"foo\"\n";
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Now verify that the cached data is not used.
RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
&headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests that restarting a partial request when the cached data cannot be
// revalidated logs an event.
TEST_F(HttpCacheTest, RangeGET_NoValidation_LogsRestart) {
MockHttpCache cache;
cache.FailConditionalizations();
// Write to the cache (40-49).
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
transaction.response_headers = "Content-Length: 10\n"
"ETag: \"foo\"\n";
RunTransactionTest(cache.http_cache(), transaction);
// Now verify that the cached data is not used.
RecordingNetLogObserver net_log_observer;
RunTransactionTestWithLog(cache.http_cache(), kRangeGET_TransactionOK,
NetLogWithSource::Make(NetLogSourceType::NONE));
EXPECT_TRUE(LogContainsEventType(
net_log_observer, NetLogEventType::HTTP_CACHE_RESTART_PARTIAL_REQUEST));
}
// Tests that a failure to conditionalize a regular request (no range) with a
// sparse entry results in a full response.
TEST_F(HttpCacheTest, GET_NoConditionalization) {
for (bool use_memory_entry_data : {false, true}) {
MockHttpCache cache;
cache.disk_cache()->set_support_in_memory_entry_data(use_memory_entry_data);
cache.FailConditionalizations();
std::string headers;
// Write to the cache (40-49).
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
transaction.response_headers =
"Content-Length: 10\n"
"ETag: \"foo\"\n";
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Now verify that the cached data is not used.
// Don't ask for a range. The cache will attempt to use the cached data but
// should discard it as it cannot be validated. A regular request should go
// to the server and a new entry should be created.
transaction.request_headers = EXTRA_HEADER;
transaction.data = "Not a range";
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
EXPECT_EQ(0U, headers.find("HTTP/1.1 200 OK\n"));
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
// The last response was saved.
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(3, cache.network_layer()->transaction_count());
if (use_memory_entry_data) {
// The cache entry isn't really useful, since when
// &RangeTransactionServer::RangeHandler gets a non-range request,
// (the network transaction #2) it returns headers without ETag,
// Last-Modified or caching headers, with a Date in 2007 (so no heuristic
// freshness), so it's both expired and not conditionalizable --- so in
// this branch we avoid opening it.
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(3, cache.disk_cache()->create_count());
} else {
EXPECT_EQ(2, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
}
}
// Verifies that conditionalization failures when asking for a range that would
// require the cache to modify the range to ask, result in a network request
// that matches the user's one.
TEST_F(HttpCacheTest, RangeGET_NoConditionalization2) {
MockHttpCache cache;
cache.FailConditionalizations();
std::string headers;
// Write to the cache (40-49).
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
transaction.response_headers = "Content-Length: 10\n"
"ETag: \"foo\"\n";
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Now verify that the cached data is not used.
// Ask for a range that extends before and after the cached data so that the
// cache would normally mix data from three sources. After deleting the entry,
// the response will come from a single network request.
transaction.request_headers = "Range: bytes = 20-59\r\n" EXTRA_HEADER;
transaction.data = "rg: 20-29 rg: 30-39 rg: 40-49 rg: 50-59 ";
transaction.response_headers = kRangeGET_TransactionOK.response_headers;
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 20, 59);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
// The last response was saved.
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(2, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests that we cache partial responses that lack content-length.
TEST_F(HttpCacheTest, RangeGET_NoContentLength) {
MockHttpCache cache;
std::string headers;
// Attempt to write to the cache (40-49).
MockTransaction transaction(kRangeGET_TransactionOK);
AddMockTransaction(&transaction);
transaction.response_headers = "ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
"Content-Range: bytes 40-49/80\n";
transaction.handler = nullptr;
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Now verify that there's no cached data.
transaction.handler = &RangeTransactionServer::RangeHandler;
RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
&headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests that we can cache range requests and fetch random blocks from the
// cache and the network.
TEST_F(HttpCacheTest, RangeGET_OK) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
std::string headers;
// Write to the cache (40-49).
RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
&headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Read from the cache (40-49).
RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
&headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Make sure we are done with the previous transaction.
base::RunLoop().RunUntilIdle();
// Write to the cache (30-39).
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = "Range: bytes = 30-39\r\n" EXTRA_HEADER;
transaction.data = "rg: 30-39 ";
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 30, 39);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(2, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Make sure we are done with the previous transaction.
base::RunLoop().RunUntilIdle();
// Write and read from the cache (20-59).
transaction.request_headers = "Range: bytes = 20-59\r\n" EXTRA_HEADER;
transaction.data = "rg: 20-29 rg: 30-39 rg: 40-49 rg: 50-59 ";
LoadTimingInfo load_timing_info;
RunTransactionTestWithResponseAndGetTiming(
cache.http_cache(), transaction, &headers,
NetLogWithSource::Make(NetLogSourceType::NONE), &load_timing_info);
Verify206Response(headers, 20, 59);
EXPECT_EQ(4, cache.network_layer()->transaction_count());
EXPECT_EQ(3, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
TestLoadTimingNetworkRequest(load_timing_info);
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
TEST_F(HttpCacheTest, RangeGET_CacheReadError) {
// Tests recovery on cache read error on range request.
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
std::string headers;
// Write to the cache (40-49).
RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
&headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
cache.disk_cache()->set_soft_failures_one_instance(MockDiskEntry::FAIL_ALL);
// Try to read from the cache (40-49), which will fail quickly enough to
// restart, due to the failure injected above. This should still be a range
// request. (https://crbug.com/891212)
RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
&headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
// Tests that range requests with no-store get correct content-length
// (https://crbug.com/700197).
TEST_F(HttpCacheTest, RangeGET_NoStore) {
MockHttpCache cache;
MockTransaction transaction(kRangeGET_TransactionOK);
std::string response_headers = base::StrCat(
{kRangeGET_TransactionOK.response_headers, "Cache-Control: no-store\n"});
transaction.response_headers = response_headers.c_str();
AddMockTransaction(&transaction);
std::string headers;
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests a 304 setting no-store on existing 206 entry.
TEST_F(HttpCacheTest, RangeGET_NoStore304) {
MockHttpCache cache;
MockTransaction transaction(kRangeGET_TransactionOK);
std::string response_headers = base::StrCat(
{kRangeGET_TransactionOK.response_headers, "Cache-Control: max-age=0\n"});
transaction.response_headers = response_headers.c_str();
AddMockTransaction(&transaction);
std::string headers;
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
response_headers = base::StrCat(
{kRangeGET_TransactionOK.response_headers, "Cache-Control: no-store\n"});
transaction.response_headers = response_headers.c_str();
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Fetch again, this one should be from newly created cache entry, due to
// earlier no-store.
transaction.response_headers = kRangeGET_TransactionOK.response_headers;
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
Verify206Response(headers, 40, 49);
RemoveMockTransaction(&transaction);
}
// Tests that we can cache range requests and fetch random blocks from the
// cache and the network, with synchronous responses.
TEST_F(HttpCacheTest, RangeGET_SyncOK) {
MockHttpCache cache;
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.test_mode = TEST_MODE_SYNC_ALL;
AddMockTransaction(&transaction);
// Write to the cache (40-49).
std::string headers;
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Read from the cache (40-49).
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Make sure we are done with the previous transaction.
base::RunLoop().RunUntilIdle();
// Write to the cache (30-39).
transaction.request_headers = "Range: bytes = 30-39\r\n" EXTRA_HEADER;
transaction.data = "rg: 30-39 ";
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 30, 39);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Make sure we are done with the previous transaction.
base::RunLoop().RunUntilIdle();
// Write and read from the cache (20-59).
transaction.request_headers = "Range: bytes = 20-59\r\n" EXTRA_HEADER;
transaction.data = "rg: 20-29 rg: 30-39 rg: 40-49 rg: 50-59 ";
LoadTimingInfo load_timing_info;
RunTransactionTestWithResponseAndGetTiming(
cache.http_cache(), transaction, &headers,
NetLogWithSource::Make(NetLogSourceType::NONE), &load_timing_info);
Verify206Response(headers, 20, 59);
EXPECT_EQ(4, cache.network_layer()->transaction_count());
EXPECT_EQ(2, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
TestLoadTimingNetworkRequest(load_timing_info);
RemoveMockTransaction(&transaction);
}
// Tests that if the previous transaction is cancelled while busy (doing sparse
// IO), a new transaction (that reuses that same ActiveEntry) waits until the
// entry is ready again.
TEST_F(HttpCacheTest, Sparse_WaitForEntry) {
MockHttpCache cache;
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
// Create a sparse entry.
RunTransactionTest(cache.http_cache(), transaction);
// Simulate a previous transaction being cancelled.
disk_cache::Entry* entry;
MockHttpRequest request(transaction);
std::string cache_key =
*cache.http_cache()->GenerateCacheKeyForRequest(&request);
ASSERT_TRUE(cache.OpenBackendEntry(cache_key, &entry));
entry->CancelSparseIO();
// Test with a range request.
RunTransactionTest(cache.http_cache(), transaction);
// Now test with a regular request.
entry->CancelSparseIO();
transaction.request_headers = EXTRA_HEADER;
transaction.data = kFullRangeData;
RunTransactionTest(cache.http_cache(), transaction);
entry->Close();
}
// Tests that we don't revalidate an entry unless we are required to do so.
TEST_F(HttpCacheTest, RangeGET_Revalidate1) {
MockHttpCache cache;
std::string headers;
// Write to the cache (40-49).
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.response_headers =
"Last-Modified: Sat, 18 Apr 2009 01:10:43 GMT\n"
"Expires: Wed, 7 Sep 2033 21:46:42 GMT\n" // Should never expire.
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
"Content-Length: 10\n";
AddMockTransaction(&transaction);
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Read from the cache (40-49).
NetLogWithSource net_log_with_source =
NetLogWithSource::Make(NetLogSourceType::NONE);
LoadTimingInfo load_timing_info;
RunTransactionTestWithResponseAndGetTiming(cache.http_cache(), transaction,
&headers, net_log_with_source,
&load_timing_info);
Verify206Response(headers, 40, 49);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
TestLoadTimingCachedResponse(load_timing_info);
// Read again forcing the revalidation.
transaction.load_flags |= LOAD_VALIDATE_CACHE;
RunTransactionTestWithResponseAndGetTiming(cache.http_cache(), transaction,
&headers, net_log_with_source,
&load_timing_info);
Verify206Response(headers, 40, 49);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
TestLoadTimingNetworkRequest(load_timing_info);
RemoveMockTransaction(&transaction);
}
// Checks that we revalidate an entry when the headers say so.
TEST_F(HttpCacheTest, RangeGET_Revalidate2) {
MockHttpCache cache;
std::string headers;
// Write to the cache (40-49).
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.response_headers =
"Last-Modified: Sat, 18 Apr 2009 01:10:43 GMT\n"
"Expires: Sat, 18 Apr 2009 01:10:43 GMT\n" // Expired.
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
"Content-Length: 10\n";
AddMockTransaction(&transaction);
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Read from the cache (40-49).
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests that we deal with 304s for range requests.
TEST_F(HttpCacheTest, RangeGET_304) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
std::string headers;
// Write to the cache (40-49).
RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
&headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Read from the cache (40-49).
RangeTransactionServer handler;
handler.set_not_modified(true);
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.load_flags |= LOAD_VALIDATE_CACHE;
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
// Tests that we deal with 206s when revalidating range requests.
TEST_F(HttpCacheTest, RangeGET_ModifiedResult) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
std::string headers;
// Write to the cache (40-49).
RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
&headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Attempt to read from the cache (40-49).
RangeTransactionServer handler;
handler.set_modified(true);
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.load_flags |= LOAD_VALIDATE_CACHE;
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// And the entry should be gone.
RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
// Tests that when a server returns 206 with a sub-range of the requested range,
// and there is nothing stored in the cache, the returned response is passed to
// the caller as is. In this context, a subrange means a response that starts
// with the same byte that was requested, but that is not the whole range that
// was requested.
TEST_F(HttpCacheTest, RangeGET_206ReturnsSubrangeRange_NoCachedContent) {
MockHttpCache cache;
std::string headers;
// Request a large range (40-59). The server sends 40-49.
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = "Range: bytes = 40-59\r\n" EXTRA_HEADER;
transaction.response_headers =
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
"Content-Length: 10\n"
"Content-Range: bytes 40-49/80\n";
transaction.handler = nullptr;
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Tests that when a server returns 206 with a sub-range of the requested range,
// and there was an entry stored in the cache, the cache gets out of the way.
TEST_F(HttpCacheTest, RangeGET_206ReturnsSubrangeRange_CachedContent) {
MockHttpCache cache;
std::string headers;
// Write to the cache (70-79).
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = "Range: bytes = 70-79\r\n" EXTRA_HEADER;
transaction.data = "rg: 70-79 ";
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 70, 79);
// Request a large range (40-79). The cache will ask the server for 40-59.
// The server returns 40-49. The cache should consider the server confused and
// abort caching, restarting the request without caching.
transaction.request_headers = "Range: bytes = 40-79\r\n" EXTRA_HEADER;
transaction.response_headers =
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
"Content-Length: 10\n"
"Content-Range: bytes 40-49/80\n";
transaction.handler = nullptr;
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
// Two new network requests were issued, one from the cache and another after
// deleting the entry.
Verify206Response(headers, 40, 49);
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// The entry was deleted.
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(4, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests that when a server returns 206 with a sub-range of the requested range,
// and there was an entry stored in the cache, the cache gets out of the way,
// when the caller is not using ranges.
TEST_F(HttpCacheTest, GET_206ReturnsSubrangeRange_CachedContent) {
MockHttpCache cache;
std::string headers;
// Write to the cache (70-79).
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = "Range: bytes = 70-79\r\n" EXTRA_HEADER;
transaction.data = "rg: 70-79 ";
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 70, 79);
// Don't ask for a range. The cache will ask the server for 0-69.
// The server returns 40-49. The cache should consider the server confused and
// abort caching, restarting the request.
// The second network request should not be a byte range request so the server
// should return 200 + "Not a range"
transaction.request_headers = "X-Return-Default-Range:\r\n" EXTRA_HEADER;
transaction.data = "Not a range";
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
EXPECT_EQ(0U, headers.find("HTTP/1.1 200 OK\n"));
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// The entry was deleted.
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(4, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests that when a server returns 206 with a random range and there is
// nothing stored in the cache, the returned response is passed to the caller
// as is. In this context, a WrongRange means that the returned range may or may
// not have any relationship with the requested range (may or may not be
// contained). The important part is that the first byte doesn't match the first
// requested byte.
TEST_F(HttpCacheTest, RangeGET_206ReturnsWrongRange_NoCachedContent) {
MockHttpCache cache;
std::string headers;
// Request a large range (30-59). The server sends (40-49).
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = "Range: bytes = 30-59\r\n" EXTRA_HEADER;
transaction.response_headers =
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
"Content-Length: 10\n"
"Content-Range: bytes 40-49/80\n";
transaction.handler = nullptr;
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// The entry was deleted.
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests that when a server returns 206 with a random range and there is
// an entry stored in the cache, the cache gets out of the way.
TEST_F(HttpCacheTest, RangeGET_206ReturnsWrongRange_CachedContent) {
MockHttpCache cache;
std::string headers;
// Write to the cache (70-79).
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = "Range: bytes = 70-79\r\n" EXTRA_HEADER;
transaction.data = "rg: 70-79 ";
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 70, 79);
// Request a large range (30-79). The cache will ask the server for 30-69.
// The server returns 40-49. The cache should consider the server confused and
// abort caching, returning the weird range to the caller.
transaction.request_headers = "Range: bytes = 30-79\r\n" EXTRA_HEADER;
transaction.response_headers =
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
"Content-Length: 10\n"
"Content-Range: bytes 40-49/80\n";
transaction.handler = nullptr;
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// The entry was deleted.
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(4, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests that when a caller asks for a range beyond EOF, with an empty cache,
// the response matches the one provided by the server.
TEST_F(HttpCacheTest, RangeGET_206ReturnsSmallerFile_NoCachedContent) {
MockHttpCache cache;
std::string headers;
// Request a large range (70-99). The server sends 70-79.
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = "Range: bytes = 70-99\r\n" EXTRA_HEADER;
transaction.data = "rg: 70-79 ";
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 70, 79);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
EXPECT_EQ(1, cache.disk_cache()->open_count());
}
// Tests that when a caller asks for a range beyond EOF, with a cached entry,
// the cache automatically fixes the request.
TEST_F(HttpCacheTest, RangeGET_206ReturnsSmallerFile_CachedContent) {
MockHttpCache cache;
std::string headers;
// Write to the cache (40-49).
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
// Request a large range (70-99). The server sends 70-79.
transaction.request_headers = "Range: bytes = 70-99\r\n" EXTRA_HEADER;
transaction.data = "rg: 70-79 ";
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 70, 79);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// The entry was not deleted (the range was automatically fixed).
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(2, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Tests that when a caller asks for a not-satisfiable range, the server's
// response is forwarded to the caller.
TEST_F(HttpCacheTest, RangeGET_416_NoCachedContent) {
MockHttpCache cache;
std::string headers;
// Request a range beyond EOF (80-99).
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = "Range: bytes = 80-99\r\n" EXTRA_HEADER;
transaction.data = "";
transaction.status = "HTTP/1.1 416 Requested Range Not Satisfiable";
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
EXPECT_EQ(0U, headers.find(transaction.status));
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// The entry was deleted.
RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests that we cache 301s for range requests.
TEST_F(HttpCacheTest, RangeGET_301) {
MockHttpCache cache;
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
transaction.status = "HTTP/1.1 301 Moved Permanently";
transaction.response_headers = "Location: http://www.bar.com/\n";
transaction.data = "";
transaction.handler = nullptr;
// Write to the cache.
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Read from the cache.
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Tests that we can cache range requests when the start or end is unknown.
// We start with one suffix request, followed by a request from a given point.
TEST_F(HttpCacheTest, UnknownRangeGET_1) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
std::string headers;
// Write to the cache (70-79).
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = "Range: bytes = -10\r\n" EXTRA_HEADER;
transaction.data = "rg: 70-79 ";
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 70, 79);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Make sure we are done with the previous transaction.
base::RunLoop().RunUntilIdle();
// Write and read from the cache (60-79).
transaction.request_headers = "Range: bytes = 60-\r\n" EXTRA_HEADER;
transaction.data = "rg: 60-69 rg: 70-79 ";
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 60, 79);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
// Tests that we can cache range requests when the start or end is unknown.
// We start with one request from a given point, followed by a suffix request.
// We'll also verify that synchronous cache responses work as intended.
TEST_F(HttpCacheTest, UnknownRangeGET_2) {
MockHttpCache cache;
std::string headers;
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.test_mode = TEST_MODE_SYNC_CACHE_START |
TEST_MODE_SYNC_CACHE_READ |
TEST_MODE_SYNC_CACHE_WRITE;
AddMockTransaction(&transaction);
// Write to the cache (70-79).
transaction.request_headers = "Range: bytes = 70-\r\n" EXTRA_HEADER;
transaction.data = "rg: 70-79 ";
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 70, 79);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Make sure we are done with the previous transaction.
base::RunLoop().RunUntilIdle();
// Write and read from the cache (60-79).
transaction.request_headers = "Range: bytes = -20\r\n" EXTRA_HEADER;
transaction.data = "rg: 60-69 rg: 70-79 ";
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 60, 79);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Similar to UnknownRangeGET_2, except that the resource size is empty.
// Regression test for crbug.com/813061, and probably https://crbug.com/1375128
TEST_F(HttpCacheTest, UnknownRangeGET_3) {
MockHttpCache cache;
std::string headers;
ScopedMockTransaction transaction(kSimpleGET_Transaction);
transaction.response_headers =
"Cache-Control: max-age=10000\n"
"Content-Length: 0\n",
transaction.data = "";
transaction.test_mode = TEST_MODE_SYNC_CACHE_START |
TEST_MODE_SYNC_CACHE_READ |
TEST_MODE_SYNC_CACHE_WRITE;
// Write the empty resource to the cache.
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
EXPECT_EQ(
"HTTP/1.1 200 OK\nCache-Control: max-age=10000\nContent-Length: 0\n",
headers);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Make sure we are done with the previous transaction.
base::RunLoop().RunUntilIdle();
// Write and read from the cache. This used to trigger a DCHECK
// (or loop infinitely with it off).
transaction.request_headers = "Range: bytes = -20\r\n" EXTRA_HEADER;
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
EXPECT_EQ(
"HTTP/1.1 200 OK\nCache-Control: max-age=10000\nContent-Length: 0\n",
headers);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Tests that receiving Not Modified when asking for an open range doesn't mess
// up things.
TEST_F(HttpCacheTest, UnknownRangeGET_304) {
MockHttpCache cache;
std::string headers;
MockTransaction transaction(kRangeGET_TransactionOK);
AddMockTransaction(&transaction);
RangeTransactionServer handler;
handler.set_not_modified(true);
// Ask for the end of the file, without knowing the length.
transaction.request_headers = "Range: bytes = 70-\r\n" EXTRA_HEADER;
transaction.data = "";
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
// We just bypass the cache.
EXPECT_EQ(0U, headers.find("HTTP/1.1 304 Not Modified\n"));
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests that we can handle non-range requests when we have cached a range.
TEST_F(HttpCacheTest, GET_Previous206) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
std::string headers;
NetLogWithSource net_log_with_source =
NetLogWithSource::Make(NetLogSourceType::NONE);
LoadTimingInfo load_timing_info;
// Write to the cache (40-49).
RunTransactionTestWithResponseAndGetTiming(
cache.http_cache(), kRangeGET_TransactionOK, &headers,
net_log_with_source, &load_timing_info);
Verify206Response(headers, 40, 49);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
TestLoadTimingNetworkRequest(load_timing_info);
// Write and read from the cache (0-79), when not asked for a range.
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = EXTRA_HEADER;
transaction.data = kFullRangeData;
RunTransactionTestWithResponseAndGetTiming(cache.http_cache(), transaction,
&headers, net_log_with_source,
&load_timing_info);
EXPECT_EQ(0U, headers.find("HTTP/1.1 200 OK\n"));
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
TestLoadTimingNetworkRequest(load_timing_info);
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
// Tests that we can handle non-range requests when we have cached the first
// part of the object and the server replies with 304 (Not Modified).
TEST_F(HttpCacheTest, GET_Previous206_NotModified) {
MockHttpCache cache;
MockTransaction transaction(kRangeGET_TransactionOK);
AddMockTransaction(&transaction);
std::string headers;
NetLogWithSource net_log_with_source =
NetLogWithSource::Make(NetLogSourceType::NONE);
LoadTimingInfo load_timing_info;
// Write to the cache (0-9).
transaction.request_headers = "Range: bytes = 0-9\r\n" EXTRA_HEADER;
transaction.data = "rg: 00-09 ";
RunTransactionTestWithResponseAndGetTiming(cache.http_cache(), transaction,
&headers, net_log_with_source,
&load_timing_info);
Verify206Response(headers, 0, 9);
TestLoadTimingNetworkRequest(load_timing_info);
// Write to the cache (70-79).
transaction.request_headers = "Range: bytes = 70-79\r\n" EXTRA_HEADER;
transaction.data = "rg: 70-79 ";
RunTransactionTestWithResponseAndGetTiming(cache.http_cache(), transaction,
&headers, net_log_with_source,
&load_timing_info);
Verify206Response(headers, 70, 79);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
TestLoadTimingNetworkRequest(load_timing_info);
// Read from the cache (0-9), write and read from cache (10 - 79).
transaction.load_flags |= LOAD_VALIDATE_CACHE;
transaction.request_headers = "Foo: bar\r\n" EXTRA_HEADER;
transaction.data = kFullRangeData;
RunTransactionTestWithResponseAndGetTiming(cache.http_cache(), transaction,
&headers, net_log_with_source,
&load_timing_info);
EXPECT_EQ(0U, headers.find("HTTP/1.1 200 OK\n"));
EXPECT_EQ(4, cache.network_layer()->transaction_count());
EXPECT_EQ(2, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
TestLoadTimingNetworkRequest(load_timing_info);
RemoveMockTransaction(&transaction);
}
// Tests that we can handle a regular request to a sparse entry, that results in
// new content provided by the server (206).
TEST_F(HttpCacheTest, GET_Previous206_NewContent) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
std::string headers;
// Write to the cache (0-9).
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = "Range: bytes = 0-9\r\n" EXTRA_HEADER;
transaction.data = "rg: 00-09 ";
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 0, 9);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Now we'll issue a request without any range that should result first in a
// 206 (when revalidating), and then in a weird standard answer: the test
// server will not modify the response so we'll get the default range... a
// real server will answer with 200.
MockTransaction transaction2(kRangeGET_TransactionOK);
transaction2.request_headers = EXTRA_HEADER;
transaction2.load_flags |= LOAD_VALIDATE_CACHE;
transaction2.data = "Not a range";
RangeTransactionServer handler;
handler.set_modified(true);
LoadTimingInfo load_timing_info;
RunTransactionTestWithResponseAndGetTiming(
cache.http_cache(), transaction2, &headers,
NetLogWithSource::Make(NetLogSourceType::NONE), &load_timing_info);
EXPECT_EQ(0U, headers.find("HTTP/1.1 200 OK\n"));
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
TestLoadTimingNetworkRequest(load_timing_info);
// Verify that the previous request deleted the entry.
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests that we can handle cached 206 responses that are not sparse.
TEST_F(HttpCacheTest, GET_Previous206_NotSparse) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
// Create a disk cache entry that stores 206 headers while not being sparse.
disk_cache::Entry* entry;
ASSERT_TRUE(cache.CreateBackendEntry(request.CacheKey(), &entry, nullptr));
std::string raw_headers(kRangeGET_TransactionOK.status);
raw_headers.append("\n");
raw_headers.append(kRangeGET_TransactionOK.response_headers);
HttpResponseInfo response;
response.headers = base::MakeRefCounted<HttpResponseHeaders>(
HttpUtil::AssembleRawHeaders(raw_headers));
EXPECT_TRUE(MockHttpCache::WriteResponseInfo(entry, &response, true, false));
scoped_refptr<IOBuffer> buf(base::MakeRefCounted<IOBuffer>(500));
int len = static_cast<int>(base::strlcpy(buf->data(),
kRangeGET_TransactionOK.data, 500));
TestCompletionCallback cb;
int rv = entry->WriteData(1, 0, buf.get(), len, cb.callback(), true);
EXPECT_EQ(len, cb.GetResult(rv));
entry->Close();
// Now see that we don't use the stored entry.
std::string headers;
LoadTimingInfo load_timing_info;
RunTransactionTestWithResponseAndGetTiming(
cache.http_cache(), kSimpleGET_Transaction, &headers,
NetLogWithSource::Make(NetLogSourceType::NONE), &load_timing_info);
// We are expecting a 200.
std::string expected_headers(kSimpleGET_Transaction.status);
expected_headers.append("\n");
expected_headers.append(kSimpleGET_Transaction.response_headers);
EXPECT_EQ(expected_headers, headers);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
TestLoadTimingNetworkRequest(load_timing_info);
}
// Tests that we can handle cached 206 responses that are not sparse. This time
// we issue a range request and expect to receive a range.
TEST_F(HttpCacheTest, RangeGET_Previous206_NotSparse_2) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
// Create a disk cache entry that stores 206 headers while not being sparse.
MockHttpRequest request(kRangeGET_TransactionOK);
disk_cache::Entry* entry;
ASSERT_TRUE(cache.CreateBackendEntry(request.CacheKey(), &entry, nullptr));
std::string raw_headers(kRangeGET_TransactionOK.status);
raw_headers.append("\n");
raw_headers.append(kRangeGET_TransactionOK.response_headers);
HttpResponseInfo response;
response.headers = base::MakeRefCounted<HttpResponseHeaders>(
HttpUtil::AssembleRawHeaders(raw_headers));
EXPECT_TRUE(MockHttpCache::WriteResponseInfo(entry, &response, true, false));
scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(500);
int len = static_cast<int>(base::strlcpy(buf->data(),
kRangeGET_TransactionOK.data, 500));
TestCompletionCallback cb;
int rv = entry->WriteData(1, 0, buf.get(), len, cb.callback(), true);
EXPECT_EQ(len, cb.GetResult(rv));
entry->Close();
// Now see that we don't use the stored entry.
std::string headers;
RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
&headers);
// We are expecting a 206.
Verify206Response(headers, 40, 49);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
// Tests that we can handle cached 206 responses that can't be validated.
TEST_F(HttpCacheTest, GET_Previous206_NotValidation) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
// Create a disk cache entry that stores 206 headers.
disk_cache::Entry* entry;
ASSERT_TRUE(cache.CreateBackendEntry(request.CacheKey(), &entry, nullptr));
// Make sure that the headers cannot be validated with the server.
std::string raw_headers(kRangeGET_TransactionOK.status);
raw_headers.append("\n");
raw_headers.append("Content-Length: 80\n");
HttpResponseInfo response;
response.headers = base::MakeRefCounted<HttpResponseHeaders>(
HttpUtil::AssembleRawHeaders(raw_headers));
EXPECT_TRUE(MockHttpCache::WriteResponseInfo(entry, &response, true, false));
scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(500);
int len = static_cast<int>(base::strlcpy(buf->data(),
kRangeGET_TransactionOK.data, 500));
TestCompletionCallback cb;
int rv = entry->WriteData(1, 0, buf.get(), len, cb.callback(), true);
EXPECT_EQ(len, cb.GetResult(rv));
entry->Close();
// Now see that we don't use the stored entry.
std::string headers;
RunTransactionTestWithResponse(cache.http_cache(), kSimpleGET_Transaction,
&headers);
// We are expecting a 200.
std::string expected_headers(kSimpleGET_Transaction.status);
expected_headers.append("\n");
expected_headers.append(kSimpleGET_Transaction.response_headers);
EXPECT_EQ(expected_headers, headers);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests that we can handle range requests with cached 200 responses.
TEST_F(HttpCacheTest, RangeGET_Previous200) {
MockHttpCache cache;
// Store the whole thing with status 200.
MockTransaction transaction(kTypicalGET_Transaction);
transaction.url = kRangeGET_TransactionOK.url;
transaction.data = kFullRangeData;
AddMockTransaction(&transaction);
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
AddMockTransaction(&kRangeGET_TransactionOK);
// Now see that we use the stored entry.
std::string headers;
MockTransaction transaction2(kRangeGET_TransactionOK);
RangeTransactionServer handler;
handler.set_not_modified(true);
RunTransactionTestWithResponse(cache.http_cache(), transaction2, &headers);
// We are expecting a 206.
Verify206Response(headers, 40, 49);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// The last transaction has finished so make sure the entry is deactivated.
base::RunLoop().RunUntilIdle();
// Make a request for an invalid range.
MockTransaction transaction3(kRangeGET_TransactionOK);
transaction3.request_headers = "Range: bytes = 80-90\r\n" EXTRA_HEADER;
transaction3.data = transaction.data;
transaction3.load_flags = LOAD_SKIP_CACHE_VALIDATION;
RunTransactionTestWithResponse(cache.http_cache(), transaction3, &headers);
EXPECT_EQ(2, cache.disk_cache()->open_count());
EXPECT_EQ(0U, headers.find("HTTP/1.1 200 "));
EXPECT_EQ(std::string::npos, headers.find("Content-Range:"));
EXPECT_EQ(std::string::npos, headers.find("Content-Length: 80"));
// Make sure the entry is deactivated.
base::RunLoop().RunUntilIdle();
// Even though the request was invalid, we should have the entry.
RunTransactionTest(cache.http_cache(), transaction2);
EXPECT_EQ(3, cache.disk_cache()->open_count());
// Make sure the entry is deactivated.
base::RunLoop().RunUntilIdle();
// Now we should receive a range from the server and drop the stored entry.
handler.set_not_modified(false);
transaction2.request_headers = kRangeGET_TransactionOK.request_headers;
RunTransactionTestWithResponse(cache.http_cache(), transaction2, &headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(4, cache.network_layer()->transaction_count());
EXPECT_EQ(4, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RunTransactionTest(cache.http_cache(), transaction2);
EXPECT_EQ(2, cache.disk_cache()->create_count());
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
// Tests that we can handle a 200 response when dealing with sparse entries.
TEST_F(HttpCacheTest, RangeRequestResultsIn200) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
std::string headers;
// Write to the cache (70-79).
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = "Range: bytes = -10\r\n" EXTRA_HEADER;
transaction.data = "rg: 70-79 ";
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 70, 79);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Now we'll issue a request that results in a plain 200 response, but to
// the to the same URL that we used to store sparse data, and making sure
// that we ask for a range.
RemoveMockTransaction(&kRangeGET_TransactionOK);
MockTransaction transaction2(kSimpleGET_Transaction);
transaction2.url = kRangeGET_TransactionOK.url;
transaction2.request_headers = kRangeGET_TransactionOK.request_headers;
AddMockTransaction(&transaction2);
RunTransactionTestWithResponse(cache.http_cache(), transaction2, &headers);
std::string expected_headers(kSimpleGET_Transaction.status);
expected_headers.append("\n");
expected_headers.append(kSimpleGET_Transaction.response_headers);
EXPECT_EQ(expected_headers, headers);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction2);
}
// Tests that a range request that falls outside of the size that we know about
// only deletes the entry if the resource has indeed changed.
TEST_F(HttpCacheTest, RangeGET_MoreThanCurrentSize) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
std::string headers;
// Write to the cache (40-49).
RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
&headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// A weird request should not delete this entry. Ask for bytes 120-.
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = "Range: bytes = 120-\r\n" EXTRA_HEADER;
transaction.data = "";
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
EXPECT_EQ(0U, headers.find("HTTP/1.1 416 "));
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
EXPECT_EQ(2, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
// Tests that we don't delete a sparse entry when we cancel a request.
TEST_F(HttpCacheTest, RangeGET_Cancel) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
MockHttpRequest request(kRangeGET_TransactionOK);
auto c = std::make_unique<Context>();
int rv = cache.CreateTransaction(&c->trans);
ASSERT_THAT(rv, IsOk());
rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
if (rv == ERR_IO_PENDING)
rv = c->callback.WaitForResult();
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Make sure that the entry has some data stored.
scoped_refptr<IOBufferWithSize> buf =
base::MakeRefCounted<IOBufferWithSize>(10);
rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
if (rv == ERR_IO_PENDING)
rv = c->callback.WaitForResult();
EXPECT_EQ(buf->size(), rv);
// Destroy the transaction.
c.reset();
// Verify that the entry has not been deleted.
disk_cache::Entry* entry;
ASSERT_TRUE(cache.OpenBackendEntry(request.CacheKey(), &entry));
entry->Close();
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
// Tests that we don't mark an entry as truncated if it is partial and not
// already truncated.
TEST_F(HttpCacheTest, RangeGET_CancelWhileReading) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
MockHttpRequest request(kRangeGET_TransactionOK);
auto context = std::make_unique<Context>();
int rv = cache.CreateTransaction(&context->trans);
ASSERT_THAT(rv, IsOk());
rv = context->trans->Start(&request, context->callback.callback(),
NetLogWithSource());
if (rv == ERR_IO_PENDING)
rv = context->callback.WaitForResult();
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Start Read.
scoped_refptr<IOBufferWithSize> buf =
base::MakeRefCounted<IOBufferWithSize>(5);
rv = context->trans->Read(buf.get(), buf->size(),
context->callback.callback());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
// Destroy the transaction.
context.reset();
// Complete Read.
base::RunLoop().RunUntilIdle();
// Verify that the entry has not been marked as truncated.
VerifyTruncatedFlag(&cache, request.CacheKey(), false, 0);
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
// Tests that we don't delete a sparse entry when we start a new request after
// cancelling the previous one.
TEST_F(HttpCacheTest, RangeGET_Cancel2) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
MockHttpRequest request(kRangeGET_TransactionOK);
request.load_flags |= LOAD_VALIDATE_CACHE;
auto c = std::make_unique<Context>();
int rv = cache.CreateTransaction(&c->trans);
ASSERT_THAT(rv, IsOk());
rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
if (rv == ERR_IO_PENDING)
rv = c->callback.WaitForResult();
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Make sure that we revalidate the entry and read from the cache (a single
// read will return while waiting for the network).
scoped_refptr<IOBufferWithSize> buf =
base::MakeRefCounted<IOBufferWithSize>(5);
rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
EXPECT_EQ(5, c->callback.GetResult(rv));
rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
// Destroy the transaction before completing the read.
c.reset();
// We have the read and the delete (OnProcessPendingQueue) waiting on the
// message loop. This means that a new transaction will just reuse the same
// active entry (no open or create).
RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
// A slight variation of the previous test, this time we cancel two requests in
// a row, making sure that the second is waiting for the entry to be ready.
TEST_F(HttpCacheTest, RangeGET_Cancel3) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
MockHttpRequest request(kRangeGET_TransactionOK);
request.load_flags |= LOAD_VALIDATE_CACHE;
auto c = std::make_unique<Context>();
int rv = cache.CreateTransaction(&c->trans);
ASSERT_THAT(rv, IsOk());
rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
rv = c->callback.WaitForResult();
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Make sure that we revalidate the entry and read from the cache (a single
// read will return while waiting for the network).
scoped_refptr<IOBufferWithSize> buf =
base::MakeRefCounted<IOBufferWithSize>(5);
rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
EXPECT_EQ(5, c->callback.GetResult(rv));
rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
// Destroy the previous transaction before completing the read.
c.reset();
// We have the read and the delete (OnProcessPendingQueue) waiting on the
// message loop. This means that a new transaction will just reuse the same
// active entry (no open or create).
c = std::make_unique<Context>();
rv = cache.CreateTransaction(&c->trans);
ASSERT_THAT(rv, IsOk());
rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
MockDiskEntry::IgnoreCallbacks(true);
base::RunLoop().RunUntilIdle();
MockDiskEntry::IgnoreCallbacks(false);
// The new transaction is waiting for the query range callback.
c.reset();
// And we should not crash when the callback is delivered.
base::RunLoop().RunUntilIdle();
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
// Tests that an invalid range response results in no cached entry.
TEST_F(HttpCacheTest, RangeGET_InvalidResponse1) {
MockHttpCache cache;
std::string headers;
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.handler = nullptr;
transaction.response_headers = "Content-Range: bytes 40-49/45\n"
"Content-Length: 10\n";
AddMockTransaction(&transaction);
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
std::string expected(transaction.status);
expected.append("\n");
expected.append(transaction.response_headers);
EXPECT_EQ(expected, headers);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Verify that we don't have a cached entry.
disk_cache::Entry* entry;
MockHttpRequest request(transaction);
EXPECT_FALSE(cache.OpenBackendEntry(request.CacheKey(), &entry));
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
// Tests that we reject a range that doesn't match the content-length.
TEST_F(HttpCacheTest, RangeGET_InvalidResponse2) {
MockHttpCache cache;
std::string headers;
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.handler = nullptr;
transaction.response_headers = "Content-Range: bytes 40-49/80\n"
"Content-Length: 20\n";
AddMockTransaction(&transaction);
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
std::string expected(transaction.status);
expected.append("\n");
expected.append(transaction.response_headers);
EXPECT_EQ(expected, headers);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Verify that we don't have a cached entry.
disk_cache::Entry* entry;
MockHttpRequest request(transaction);
EXPECT_FALSE(cache.OpenBackendEntry(request.CacheKey(), &entry));
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
// Tests that if a server tells us conflicting information about a resource we
// drop the entry.
TEST_F(HttpCacheTest, RangeGET_InvalidResponse3) {
MockHttpCache cache;
std::string headers;
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.handler = nullptr;
transaction.request_headers = "Range: bytes = 50-59\r\n" EXTRA_HEADER;
std::string response_headers(transaction.response_headers);
response_headers.append("Content-Range: bytes 50-59/160\n");
transaction.response_headers = response_headers.c_str();
AddMockTransaction(&transaction);
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 50, 59);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
AddMockTransaction(&kRangeGET_TransactionOK);
// This transaction will report a resource size of 80 bytes, and we think it's
// 160 so we should ignore the response.
RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
&headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Verify that the entry is gone.
RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
// Tests that we handle large range values properly.
TEST_F(HttpCacheTest, RangeGET_LargeValues) {
// We need a real sparse cache for this test.
MockHttpCache cache(HttpCache::DefaultBackend::InMemory(1024 * 1024));
std::string headers;
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.handler = nullptr;
transaction.request_headers = "Range: bytes = 4294967288-4294967297\r\n"
EXTRA_HEADER;
transaction.response_headers =
"ETag: \"foo\"\n"
"Content-Range: bytes 4294967288-4294967297/4294967299\n"
"Content-Length: 10\n";
AddMockTransaction(&transaction);
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
std::string expected(transaction.status);
expected.append("\n");
expected.append(transaction.response_headers);
EXPECT_EQ(expected, headers);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
// Verify that we have a cached entry.
disk_cache::Entry* en;
MockHttpRequest request(transaction);
ASSERT_TRUE(cache.OpenBackendEntry(request.CacheKey(), &en));
en->Close();
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
// Tests that we don't crash with a range request if the disk cache was not
// initialized properly.
TEST_F(HttpCacheTest, RangeGET_NoDiskCache) {
auto factory = std::make_unique<MockBlockingBackendFactory>();
factory->set_fail(true);
factory->FinishCreation(); // We'll complete synchronously.
MockHttpCache cache(std::move(factory));
AddMockTransaction(&kRangeGET_TransactionOK);
RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
// Tests that we handle byte range requests that skip the cache.
TEST_F(HttpCacheTest, RangeHEAD) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = "Range: bytes = -10\r\n" EXTRA_HEADER;
transaction.method = "HEAD";
transaction.data = "rg: 70-79 ";
std::string headers;
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
Verify206Response(headers, 70, 79);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(0, cache.disk_cache()->create_count());
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
// Tests that we don't crash when after reading from the cache we issue a
// request for the next range and the server gives us a 200 synchronously.
TEST_F(HttpCacheTest, RangeGET_FastFlakyServer) {
MockHttpCache cache;
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = "Range: bytes = 40-\r\n" EXTRA_HEADER;
transaction.test_mode = TEST_MODE_SYNC_NET_START;
transaction.load_flags |= LOAD_VALIDATE_CACHE;
// Write to the cache.
RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
// And now read from the cache and the network.
RangeTransactionServer handler;
handler.set_bad_200(true);
transaction.data = "Not a range";
RecordingNetLogObserver net_log_observer;
RunTransactionTestWithLog(cache.http_cache(), transaction,
NetLogWithSource::Make(NetLogSourceType::NONE));
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
EXPECT_TRUE(LogContainsEventType(
net_log_observer, NetLogEventType::HTTP_CACHE_RE_SEND_PARTIAL_REQUEST));
}
// Tests that when the server gives us less data than expected, we don't keep
// asking for more data.
TEST_F(HttpCacheTest, RangeGET_FastFlakyServer2) {
MockHttpCache cache;
// First, check with an empty cache (WRITE mode).
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = "Range: bytes = 40-49\r\n" EXTRA_HEADER;
transaction.data = "rg: 40-"; // Less than expected.
transaction.handler = nullptr;
std::string headers(transaction.response_headers);
headers.append("Content-Range: bytes 40-49/80\n");
transaction.response_headers = headers.c_str();
AddMockTransaction(&transaction);
// Write to the cache.
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Now verify that even in READ_WRITE mode, we forward the bad response to
// the caller.
transaction.request_headers = "Range: bytes = 60-69\r\n" EXTRA_HEADER;
transaction.data = "rg: 60-"; // Less than expected.
headers = kRangeGET_TransactionOK.response_headers;
headers.append("Content-Range: bytes 60-69/80\n");
transaction.response_headers = headers.c_str();
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
TEST_F(HttpCacheTest, RangeGET_OK_LoadOnlyFromCache) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
// Write to the cache (40-49).
RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Force this transaction to read from the cache.
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
MockHttpRequest request(transaction);
TestCompletionCallback callback;
std::unique_ptr<HttpTransaction> trans;
int rv = cache.http_cache()->CreateTransaction(DEFAULT_PRIORITY, &trans);
EXPECT_THAT(rv, IsOk());
ASSERT_TRUE(trans.get());
rv = trans->Start(&request, callback.callback(), NetLogWithSource());
if (rv == ERR_IO_PENDING)
rv = callback.WaitForResult();
ASSERT_THAT(rv, IsError(ERR_CACHE_MISS));
trans.reset();
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
// Tests the handling of the "truncation" flag.
TEST_F(HttpCacheTest, WriteResponseInfo_Truncated) {
MockHttpCache cache;
disk_cache::Entry* entry;
ASSERT_TRUE(cache.CreateBackendEntry(
GenerateCacheKey("http://www.google.com"), &entry, nullptr));
HttpResponseInfo response;
response.headers = base::MakeRefCounted<HttpResponseHeaders>(
HttpUtil::AssembleRawHeaders("HTTP/1.1 200 OK"));
// Set the last argument for this to be an incomplete request.
EXPECT_TRUE(MockHttpCache::WriteResponseInfo(entry, &response, true, true));
bool truncated = false;
EXPECT_TRUE(MockHttpCache::ReadResponseInfo(entry, &response, &truncated));
EXPECT_TRUE(truncated);
// And now test the opposite case.
EXPECT_TRUE(MockHttpCache::WriteResponseInfo(entry, &response, true, false));
truncated = true;
EXPECT_TRUE(MockHttpCache::ReadResponseInfo(entry, &response, &truncated));
EXPECT_FALSE(truncated);
entry->Close();
}
// Tests basic pickling/unpickling of HttpResponseInfo.
TEST_F(HttpCacheTest, PersistHttpResponseInfo) {
const IPEndPoint expected_endpoint = IPEndPoint(IPAddress(1, 2, 3, 4), 80);
// Set some fields (add more if needed.)
HttpResponseInfo response1;
response1.was_cached = false;
response1.remote_endpoint = expected_endpoint;
response1.headers =
base::MakeRefCounted<HttpResponseHeaders>("HTTP/1.1 200 OK");
// Pickle.
base::Pickle pickle;
response1.Persist(&pickle, false, false);
// Unpickle.
HttpResponseInfo response2;
bool response_truncated;
EXPECT_TRUE(response2.InitFromPickle(pickle, &response_truncated));
EXPECT_FALSE(response_truncated);
// Verify fields.
EXPECT_TRUE(response2.was_cached); // InitFromPickle sets this flag.
EXPECT_EQ(expected_endpoint, response2.remote_endpoint);
EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
}
// Tests that we delete an entry when the request is cancelled before starting
// to read from the network.
TEST_F(HttpCacheTest, DoomOnDestruction) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
auto c = std::make_unique<Context>();
int rv = cache.CreateTransaction(&c->trans);
ASSERT_THAT(rv, IsOk());
rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
if (rv == ERR_IO_PENDING)
c->result = c->callback.WaitForResult();
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Destroy the transaction. We only have the headers so we should delete this
// entry.
c.reset();
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests that we delete an entry when the request is cancelled if the response
// does not have content-length and strong validators.
TEST_F(HttpCacheTest, DoomOnDestruction2) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
auto c = std::make_unique<Context>();
int rv = cache.CreateTransaction(&c->trans);
ASSERT_THAT(rv, IsOk());
rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
if (rv == ERR_IO_PENDING)
rv = c->callback.WaitForResult();
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Make sure that the entry has some data stored.
scoped_refptr<IOBufferWithSize> buf =
base::MakeRefCounted<IOBufferWithSize>(10);
rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
if (rv == ERR_IO_PENDING)
rv = c->callback.WaitForResult();
EXPECT_EQ(buf->size(), rv);
// Destroy the transaction.
c.reset();
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests that we delete an entry when the request is cancelled if the response
// has an "Accept-Ranges: none" header.
TEST_F(HttpCacheTest, DoomOnDestruction3) {
MockHttpCache cache;
MockTransaction transaction(kSimpleGET_Transaction);
transaction.response_headers =
"Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
"Content-Length: 22\n"
"Accept-Ranges: none\n"
"Etag: \"foopy\"\n";
AddMockTransaction(&transaction);
MockHttpRequest request(transaction);
auto c = std::make_unique<Context>();
int rv = cache.CreateTransaction(&c->trans);
ASSERT_THAT(rv, IsOk());
rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
if (rv == ERR_IO_PENDING)
rv = c->callback.WaitForResult();
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Make sure that the entry has some data stored.
scoped_refptr<IOBufferWithSize> buf =
base::MakeRefCounted<IOBufferWithSize>(10);
rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
if (rv == ERR_IO_PENDING)
rv = c->callback.WaitForResult();
EXPECT_EQ(buf->size(), rv);
// Destroy the transaction.
c.reset();
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
}
// Tests that we mark an entry as incomplete when the request is cancelled.
TEST_F(HttpCacheTest, SetTruncatedFlag) {
MockHttpCache cache;
ScopedMockTransaction transaction(kSimpleGET_Transaction);
transaction.response_headers =
"Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
"Content-Length: 22\n"
"Etag: \"foopy\"\n";
MockHttpRequest request(transaction);
auto c = std::make_unique<Context>();
int rv = cache.CreateTransaction(&c->trans);
ASSERT_THAT(rv, IsOk());
rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
if (rv == ERR_IO_PENDING)
rv = c->callback.WaitForResult();
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Make sure that the entry has some data stored.
scoped_refptr<IOBufferWithSize> buf =
base::MakeRefCounted<IOBufferWithSize>(10);
rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
if (rv == ERR_IO_PENDING)
rv = c->callback.WaitForResult();
EXPECT_EQ(buf->size(), rv);
// We want to cancel the request when the transaction is busy.
rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
EXPECT_FALSE(c->callback.have_result());
// Destroy the transaction.
c->trans.reset();
// Make sure that we don't invoke the callback. We may have an issue if the
// UrlRequestJob is killed directly (without cancelling the UrlRequest) so we
// could end up with the transaction being deleted twice if we send any
// notification from the transaction destructor (see http://crbug.com/31723).
EXPECT_FALSE(c->callback.have_result());
base::RunLoop().RunUntilIdle();
VerifyTruncatedFlag(&cache, request.CacheKey(), true, 0);
}
// Tests that we do not mark an entry as truncated when the request is
// cancelled.
TEST_F(HttpCacheTest, DontSetTruncatedFlagForGarbledResponseCode) {
MockHttpCache cache;
ScopedMockTransaction transaction(kSimpleGET_Transaction);
transaction.response_headers =
"Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
"Content-Length: 22\n"
"Etag: \"foopy\"\n";
transaction.status = "HTTP/1.1 2";
MockHttpRequest request(transaction);
auto c = std::make_unique<Context>();
int rv = cache.CreateTransaction(&c->trans);
ASSERT_THAT(rv, IsOk());
rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
if (rv == ERR_IO_PENDING)
rv = c->callback.WaitForResult();
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Make sure that the entry has some data stored.
scoped_refptr<IOBufferWithSize> buf =
base::MakeRefCounted<IOBufferWithSize>(10);
rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
if (rv == ERR_IO_PENDING)
rv = c->callback.WaitForResult();
EXPECT_EQ(buf->size(), rv);
// We want to cancel the request when the transaction is busy.
rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
EXPECT_FALSE(c->callback.have_result());
MockHttpCache::SetTestMode(TEST_MODE_SYNC_ALL);
// Destroy the transaction.
c->trans.reset();
MockHttpCache::SetTestMode(0);
// Make sure that we don't invoke the callback. We may have an issue if the
// UrlRequestJob is killed directly (without cancelling the UrlRequest) so we
// could end up with the transaction being deleted twice if we send any
// notification from the transaction destructor (see http://crbug.com/31723).
EXPECT_FALSE(c->callback.have_result());
// Verify that the entry is deleted as well, since the response status is
// garbled. Note that the entry will be deleted after the pending Read is
// complete.
base::RunLoop().RunUntilIdle();
disk_cache::Entry* entry;
ASSERT_FALSE(cache.OpenBackendEntry(request.CacheKey(), &entry));
}
// Tests that we don't mark an entry as truncated when we read everything.
TEST_F(HttpCacheTest, DontSetTruncatedFlag) {
MockHttpCache cache;
ScopedMockTransaction transaction(kSimpleGET_Transaction);
transaction.response_headers =
"Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
"Content-Length: 22\n"
"Etag: \"foopy\"\n";
MockHttpRequest request(transaction);
auto c = std::make_unique<Context>();
int rv = cache.CreateTransaction(&c->trans);
ASSERT_THAT(rv, IsOk());
rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
EXPECT_THAT(c->callback.GetResult(rv), IsOk());
// Read everything.
scoped_refptr<IOBufferWithSize> buf =
base::MakeRefCounted<IOBufferWithSize>(22);
rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
EXPECT_EQ(buf->size(), c->callback.GetResult(rv));
// Destroy the transaction.
c->trans.reset();
// Verify that the entry is not marked as truncated.
VerifyTruncatedFlag(&cache, request.CacheKey(), false, 0);
}
// Tests that sparse entries don't set the truncate flag.
TEST_F(HttpCacheTest, RangeGET_DontTruncate) {
MockHttpCache cache;
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = "Range: bytes = 0-19\r\n" EXTRA_HEADER;
auto request = std::make_unique<MockHttpRequest>(transaction);
std::unique_ptr<HttpTransaction> trans;
int rv = cache.http_cache()->CreateTransaction(DEFAULT_PRIORITY, &trans);
EXPECT_THAT(rv, IsOk());
TestCompletionCallback cb;
rv = trans->Start(request.get(), cb.callback(), NetLogWithSource());
EXPECT_EQ(0, cb.GetResult(rv));
scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(10);
rv = trans->Read(buf.get(), 10, cb.callback());
EXPECT_EQ(10, cb.GetResult(rv));
// Should not trigger any DCHECK.
trans.reset();
VerifyTruncatedFlag(&cache, request->CacheKey(), false, 0);
}
// Tests that sparse entries don't set the truncate flag (when the byte range
// starts after 0).
TEST_F(HttpCacheTest, RangeGET_DontTruncate2) {
MockHttpCache cache;
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = "Range: bytes = 30-49\r\n" EXTRA_HEADER;
auto request = std::make_unique<MockHttpRequest>(transaction);
std::unique_ptr<HttpTransaction> trans;
int rv = cache.http_cache()->CreateTransaction(DEFAULT_PRIORITY, &trans);
EXPECT_THAT(rv, IsOk());
TestCompletionCallback cb;
rv = trans->Start(request.get(), cb.callback(), NetLogWithSource());
EXPECT_EQ(0, cb.GetResult(rv));
scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(10);
rv = trans->Read(buf.get(), 10, cb.callback());
EXPECT_EQ(10, cb.GetResult(rv));
// Should not trigger any DCHECK.
trans.reset();
VerifyTruncatedFlag(&cache, request->CacheKey(), false, 0);
}
// Tests that we can continue with a request that was interrupted.
TEST_F(HttpCacheTest, GET_IncompleteResource) {
MockHttpCache cache;
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
std::string raw_headers("HTTP/1.1 200 OK\n"
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
"Content-Length: 80\n");
CreateTruncatedEntry(raw_headers, &cache);
// Now make a regular request.
std::string headers;
transaction.request_headers = EXTRA_HEADER;
transaction.data = kFullRangeData;
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
// We update the headers with the ones received while revalidating.
std::string expected_headers(
"HTTP/1.1 200 OK\n"
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"Accept-Ranges: bytes\n"
"ETag: \"foo\"\n"
"Content-Length: 80\n");
EXPECT_EQ(expected_headers, headers);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Verify that the disk entry was updated.
MockHttpRequest request(transaction);
VerifyTruncatedFlag(&cache, request.CacheKey(), false, 80);
}
// Tests the handling of no-store when revalidating a truncated entry.
TEST_F(HttpCacheTest, GET_IncompleteResource_NoStore) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
std::string raw_headers("HTTP/1.1 200 OK\n"
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
"Content-Length: 80\n");
CreateTruncatedEntry(raw_headers, &cache);
RemoveMockTransaction(&kRangeGET_TransactionOK);
// Now make a regular request.
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = EXTRA_HEADER;
std::string response_headers(transaction.response_headers);
response_headers += ("Cache-Control: no-store\n");
transaction.response_headers = response_headers.c_str();
transaction.data = kFullRangeData;
AddMockTransaction(&transaction);
std::string headers;
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
// We update the headers with the ones received while revalidating.
std::string expected_headers(
"HTTP/1.1 200 OK\n"
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"Accept-Ranges: bytes\n"
"Cache-Control: no-store\n"
"ETag: \"foo\"\n"
"Content-Length: 80\n");
EXPECT_EQ(expected_headers, headers);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Verify that the disk entry was deleted.
disk_cache::Entry* entry;
MockHttpRequest request(transaction);
EXPECT_FALSE(cache.OpenBackendEntry(request.CacheKey(), &entry));
RemoveMockTransaction(&transaction);
}
// Tests cancelling a request after the server sent no-store.
TEST_F(HttpCacheTest, GET_IncompleteResource_Cancel) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
std::string raw_headers("HTTP/1.1 200 OK\n"
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
"Content-Length: 80\n");
CreateTruncatedEntry(raw_headers, &cache);
RemoveMockTransaction(&kRangeGET_TransactionOK);
// Now make a regular request.
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = EXTRA_HEADER;
std::string response_headers(transaction.response_headers);
response_headers += ("Cache-Control: no-store\n");
transaction.response_headers = response_headers.c_str();
transaction.data = kFullRangeData;
AddMockTransaction(&transaction);
MockHttpRequest request(transaction);
auto c = std::make_unique<Context>();
int rv = cache.CreateTransaction(&c->trans);
ASSERT_THAT(rv, IsOk());
// Queue another request to this transaction. We have to start this request
// before the first one gets the response from the server and dooms the entry,
// otherwise it will just create a new entry without being queued to the first
// request.
auto pending = std::make_unique<Context>();
ASSERT_THAT(cache.CreateTransaction(&pending->trans), IsOk());
rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
EXPECT_EQ(ERR_IO_PENDING,
pending->trans->Start(&request, pending->callback.callback(),
NetLogWithSource()));
EXPECT_THAT(c->callback.GetResult(rv), IsOk());
// Make sure that the entry has some data stored.
scoped_refptr<IOBufferWithSize> buf =
base::MakeRefCounted<IOBufferWithSize>(5);
rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
EXPECT_EQ(5, c->callback.GetResult(rv));
// Since |pending| is currently validating the already written headers
// it will be restarted as well.
c.reset();
pending.reset();
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
base::RunLoop().RunUntilIdle();
RemoveMockTransaction(&transaction);
}
// Tests that we delete truncated entries if the server changes its mind midway.
TEST_F(HttpCacheTest, GET_IncompleteResource2) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
// Content-length will be intentionally bad.
std::string raw_headers("HTTP/1.1 200 OK\n"
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
"Content-Length: 50\n");
CreateTruncatedEntry(raw_headers, &cache);
// Now make a regular request. We expect the code to fail the validation and
// retry the request without using byte ranges.
std::string headers;
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = EXTRA_HEADER;
transaction.data = "Not a range";
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
// The server will return 200 instead of a byte range.
std::string expected_headers(
"HTTP/1.1 200 OK\n"
"Date: Wed, 28 Nov 2007 09:40:09 GMT\n");
EXPECT_EQ(expected_headers, headers);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Verify that the disk entry was deleted.
disk_cache::Entry* entry;
MockHttpRequest request(transaction);
ASSERT_FALSE(cache.OpenBackendEntry(request.CacheKey(), &entry));
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
// Tests that we always validate a truncated request.
TEST_F(HttpCacheTest, GET_IncompleteResource3) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
// This should not require validation for 10 hours.
std::string raw_headers("HTTP/1.1 200 OK\n"
"Last-Modified: Sat, 18 Apr 2009 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Cache-Control: max-age= 36000\n"
"Accept-Ranges: bytes\n"
"Content-Length: 80\n");
CreateTruncatedEntry(raw_headers, &cache);
// Now make a regular request.
std::string headers;
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = EXTRA_HEADER;
transaction.data = kFullRangeData;
auto c = std::make_unique<Context>();
int rv = cache.CreateTransaction(&c->trans);
ASSERT_THAT(rv, IsOk());
MockHttpRequest request(transaction);
rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
EXPECT_THAT(c->callback.GetResult(rv), IsOk());
// We should have checked with the server before finishing Start().
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
// Tests that we handle 401s for truncated resources.
TEST_F(HttpCacheTest, GET_IncompleteResourceWithAuth) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
std::string raw_headers("HTTP/1.1 200 OK\n"
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
"Content-Length: 80\n");
CreateTruncatedEntry(raw_headers, &cache);
// Now make a regular request.
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = "X-Require-Mock-Auth: dummy\r\n"
EXTRA_HEADER;
transaction.data = kFullRangeData;
RangeTransactionServer handler;
auto c = std::make_unique<Context>();
int rv = cache.CreateTransaction(&c->trans);
ASSERT_THAT(rv, IsOk());
MockHttpRequest request(transaction);
rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
EXPECT_THAT(c->callback.GetResult(rv), IsOk());
const HttpResponseInfo* response = c->trans->GetResponseInfo();
ASSERT_TRUE(response);
ASSERT_EQ(401, response->headers->response_code());
rv = c->trans->RestartWithAuth(AuthCredentials(), c->callback.callback());
EXPECT_THAT(c->callback.GetResult(rv), IsOk());
response = c->trans->GetResponseInfo();
ASSERT_TRUE(response);
ASSERT_EQ(200, response->headers->response_code());
ReadAndVerifyTransaction(c->trans.get(), transaction);
c.reset(); // The destructor could delete the entry.
EXPECT_EQ(2, cache.network_layer()->transaction_count());
// Verify that the entry was deleted.
disk_cache::Entry* entry;
ASSERT_TRUE(cache.OpenBackendEntry(request.CacheKey(), &entry));
entry->Close();
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
// Test that the transaction won't retry failed partial requests
// after it starts reading data. http://crbug.com/474835
TEST_F(HttpCacheTest, TransactionRetryLimit) {
MockHttpCache cache;
// Cache 0-9, so that we have data to read before failing.
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = "Range: bytes = 0-9\r\n" EXTRA_HEADER;
transaction.data = "rg: 00-09 ";
// Write to the cache.
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
// And now read from the cache and the network. 10-19 will get a
// 401, but will have already returned 0-9.
// We do not set X-Require-Mock-Auth because that causes the mock
// network transaction to become IsReadyToRestartForAuth().
transaction.request_headers =
"Range: bytes = 0-79\r\n"
"X-Require-Mock-Auth-Alt: dummy\r\n" EXTRA_HEADER;
auto c = std::make_unique<Context>();
int rv = cache.CreateTransaction(&c->trans);
ASSERT_THAT(rv, IsOk());
MockHttpRequest request(transaction);
rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
if (rv == ERR_IO_PENDING)
rv = c->callback.WaitForResult();
std::string content;
rv = ReadTransaction(c->trans.get(), &content);
EXPECT_THAT(rv, IsError(ERR_CACHE_AUTH_FAILURE_AFTER_READ));
}
// Tests that we cache a 200 response to the validation request.
TEST_F(HttpCacheTest, GET_IncompleteResource4) {
MockHttpCache cache;
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
std::string raw_headers("HTTP/1.1 200 OK\n"
"Last-Modified: Sat, 18 Apr 2009 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
"Content-Length: 80\n");
CreateTruncatedEntry(raw_headers, &cache);
// Now make a regular request.
std::string headers;
transaction.request_headers = EXTRA_HEADER;
transaction.data = "Not a range";
RangeTransactionServer handler;
handler.set_bad_200(true);
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Verify that the disk entry was updated.
MockHttpRequest request(transaction);
VerifyTruncatedFlag(&cache, request.CacheKey(), false, 11);
}
// Tests that when we cancel a request that was interrupted, we mark it again
// as truncated.
TEST_F(HttpCacheTest, GET_CancelIncompleteResource) {
MockHttpCache cache;
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
std::string raw_headers("HTTP/1.1 200 OK\n"
"Last-Modified: Sat, 18 Apr 2009 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
"Content-Length: 80\n");
CreateTruncatedEntry(raw_headers, &cache);
// Now make a regular request.
transaction.request_headers = EXTRA_HEADER;
MockHttpRequest request(transaction);
auto c = std::make_unique<Context>();
int rv = cache.CreateTransaction(&c->trans);
ASSERT_THAT(rv, IsOk());
rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
EXPECT_THAT(c->callback.GetResult(rv), IsOk());
// Read 20 bytes from the cache, and 10 from the net.
scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(100);
rv = c->trans->Read(buf.get(), 20, c->callback.callback());
EXPECT_EQ(20, c->callback.GetResult(rv));
rv = c->trans->Read(buf.get(), 10, c->callback.callback());
EXPECT_EQ(10, c->callback.GetResult(rv));
// At this point, we are already reading so canceling the request should leave
// a truncated one.
c.reset();
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Verify that the disk entry was updated: now we have 30 bytes.
VerifyTruncatedFlag(&cache, request.CacheKey(), true, 30);
}
// Tests that we can handle range requests when we have a truncated entry.
TEST_F(HttpCacheTest, RangeGET_IncompleteResource) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
// Content-length will be intentionally bogus.
std::string raw_headers("HTTP/1.1 200 OK\n"
"Last-Modified: something\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
"Content-Length: 10\n");
CreateTruncatedEntry(raw_headers, &cache);
// Now make a range request.
std::string headers;
RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
&headers);
Verify206Response(headers, 40, 49);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
TEST_F(HttpCacheTest, SyncRead) {
MockHttpCache cache;
// This test ensures that a read that completes synchronously does not cause
// any problems.
ScopedMockTransaction transaction(kSimpleGET_Transaction);
transaction.test_mode |= (TEST_MODE_SYNC_CACHE_START |
TEST_MODE_SYNC_CACHE_READ |
TEST_MODE_SYNC_CACHE_WRITE);
MockHttpRequest r1(transaction),
r2(transaction),
r3(transaction);
TestTransactionConsumer c1(DEFAULT_PRIORITY, cache.http_cache()),
c2(DEFAULT_PRIORITY, cache.http_cache()),
c3(DEFAULT_PRIORITY, cache.http_cache());
c1.Start(&r1, NetLogWithSource());
r2.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
c2.Start(&r2, NetLogWithSource());
r3.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
c3.Start(&r3, NetLogWithSource());
base::RunLoop().Run();
EXPECT_TRUE(c1.is_done());
EXPECT_TRUE(c2.is_done());
EXPECT_TRUE(c3.is_done());
EXPECT_THAT(c1.error(), IsOk());
EXPECT_THAT(c2.error(), IsOk());
EXPECT_THAT(c3.error(), IsOk());
}
TEST_F(HttpCacheTest, ValidationResultsIn200) {
MockHttpCache cache;
// This test ensures that a conditional request, which results in a 200
// instead of a 304, properly truncates the existing response data.
// write to the cache
RunTransactionTest(cache.http_cache(), kETagGET_Transaction);
// force this transaction to validate the cache
MockTransaction transaction(kETagGET_Transaction);
transaction.load_flags |= LOAD_VALIDATE_CACHE;
RunTransactionTest(cache.http_cache(), transaction);
// read from the cache
RunTransactionTest(cache.http_cache(), kETagGET_Transaction);
}
TEST_F(HttpCacheTest, CachedRedirect) {
MockHttpCache cache;
ScopedMockTransaction kTestTransaction(kSimpleGET_Transaction);
kTestTransaction.status = "HTTP/1.1 301 Moved Permanently";
kTestTransaction.response_headers = "Location: http://www.bar.com/\n";
MockHttpRequest request(kTestTransaction);
TestCompletionCallback callback;
// Write to the cache.
{
std::unique_ptr<HttpTransaction> trans;
ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
if (rv == ERR_IO_PENDING)
rv = callback.WaitForResult();
ASSERT_THAT(rv, IsOk());
const HttpResponseInfo* info = trans->GetResponseInfo();
ASSERT_TRUE(info);
EXPECT_EQ(info->headers->response_code(), 301);
std::string location;
info->headers->EnumerateHeader(nullptr, "Location", &location);
EXPECT_EQ(location, "http://www.bar.com/");
// Mark the transaction as completed so it is cached.
trans->DoneReading();
// Destroy transaction when going out of scope. We have not actually
// read the response body -- want to test that it is still getting cached.
}
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Active entries in the cache are not retired synchronously. Make
// sure the next run hits the MockHttpCache and open_count is
// correct.
base::RunLoop().RunUntilIdle();
// Read from the cache.
{
std::unique_ptr<HttpTransaction> trans;
ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
if (rv == ERR_IO_PENDING)
rv = callback.WaitForResult();
ASSERT_THAT(rv, IsOk());
const HttpResponseInfo* info = trans->GetResponseInfo();
ASSERT_TRUE(info);
EXPECT_EQ(info->headers->response_code(), 301);
std::string location;
info->headers->EnumerateHeader(nullptr, "Location", &location);
EXPECT_EQ(location, "http://www.bar.com/");
// Mark the transaction as completed so it is cached.
trans->DoneReading();
// Destroy transaction when going out of scope. We have not actually
// read the response body -- want to test that it is still getting cached.
}
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Verify that no-cache resources are stored in cache, but are not fetched from
// cache during normal loads.
TEST_F(HttpCacheTest, CacheControlNoCacheNormalLoad) {
for (bool use_memory_entry_data : {false, true}) {
MockHttpCache cache;
cache.disk_cache()->set_support_in_memory_entry_data(use_memory_entry_data);
ScopedMockTransaction transaction(kSimpleGET_Transaction);
transaction.response_headers = "cache-control: no-cache\n";
// Initial load.
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Try loading again; it should result in a network fetch.
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
if (use_memory_entry_data) {
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
} else {
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
disk_cache::Entry* entry;
MockHttpRequest request(transaction);
EXPECT_TRUE(cache.OpenBackendEntry(request.CacheKey(), &entry));
entry->Close();
}
}
// Verify that no-cache resources are stored in cache and fetched from cache
// when the LOAD_SKIP_CACHE_VALIDATION flag is set.
TEST_F(HttpCacheTest, CacheControlNoCacheHistoryLoad) {
MockHttpCache cache;
ScopedMockTransaction transaction(kSimpleGET_Transaction);
transaction.response_headers = "cache-control: no-cache\n";
// Initial load.
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Try loading again with LOAD_SKIP_CACHE_VALIDATION.
transaction.load_flags = LOAD_SKIP_CACHE_VALIDATION;
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
disk_cache::Entry* entry;
MockHttpRequest request(transaction);
EXPECT_TRUE(cache.OpenBackendEntry(request.CacheKey(), &entry));
entry->Close();
}
TEST_F(HttpCacheTest, CacheControlNoStore) {
MockHttpCache cache;
ScopedMockTransaction transaction(kSimpleGET_Transaction);
transaction.response_headers = "cache-control: no-store\n";
// initial load
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// try loading again; it should result in a network fetch
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
disk_cache::Entry* entry;
MockHttpRequest request(transaction);
EXPECT_FALSE(cache.OpenBackendEntry(request.CacheKey(), &entry));
}
TEST_F(HttpCacheTest, CacheControlNoStore2) {
// this test is similar to the above test, except that the initial response
// is cachable, but when it is validated, no-store is received causing the
// cached document to be deleted.
MockHttpCache cache;
ScopedMockTransaction transaction(kETagGET_Transaction);
// initial load
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// try loading again; it should result in a network fetch
transaction.load_flags = LOAD_VALIDATE_CACHE;
transaction.response_headers = "cache-control: no-store\n";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
disk_cache::Entry* entry;
MockHttpRequest request(transaction);
EXPECT_FALSE(cache.OpenBackendEntry(request.CacheKey(), &entry));
}
TEST_F(HttpCacheTest, CacheControlNoStore3) {
// this test is similar to the above test, except that the response is a 304
// instead of a 200. this should never happen in practice, but it seems like
// a good thing to verify that we still destroy the cache entry.
MockHttpCache cache;
ScopedMockTransaction transaction(kETagGET_Transaction);
// initial load
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// try loading again; it should result in a network fetch
transaction.load_flags = LOAD_VALIDATE_CACHE;
transaction.response_headers = "cache-control: no-store\n";
transaction.status = "HTTP/1.1 304 Not Modified";
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
disk_cache::Entry* entry;
MockHttpRequest request(transaction);
EXPECT_FALSE(cache.OpenBackendEntry(request.CacheKey(), &entry));
}
// Ensure that we don't cache requests served over bad HTTPS.
TEST_F(HttpCacheTest, SimpleGET_SSLError) {
MockHttpCache cache;
MockTransaction transaction = kSimpleGET_Transaction;
transaction.cert_status = CERT_STATUS_REVOKED;
ScopedMockTransaction scoped_transaction(transaction);
// write to the cache
RunTransactionTest(cache.http_cache(), transaction);
// Test that it was not cached.
transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
MockHttpRequest request(transaction);
TestCompletionCallback callback;
std::unique_ptr<HttpTransaction> trans;
ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
if (rv == ERR_IO_PENDING)
rv = callback.WaitForResult();
ASSERT_THAT(rv, IsError(ERR_CACHE_MISS));
}
// Ensure that we don't crash by if left-behind transactions.
TEST_F(HttpCacheTest, OutlivedTransactions) {
auto cache = std::make_unique<MockHttpCache>();
std::unique_ptr<HttpTransaction> trans;
EXPECT_THAT(cache->CreateTransaction(&trans), IsOk());
cache.reset();
trans.reset();
}
// Test that the disabled mode works.
TEST_F(HttpCacheTest, CacheDisabledMode) {
MockHttpCache cache;
// write to the cache
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
// go into disabled mode
cache.http_cache()->set_mode(HttpCache::DISABLE);
// force this transaction to write to the cache again
MockTransaction transaction(kSimpleGET_Transaction);
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Other tests check that the response headers of the cached response
// get updated on 304. Here we specifically check that the
// HttpResponseHeaders::request_time and HttpResponseHeaders::response_time
// fields also gets updated.
// http://crbug.com/20594.
TEST_F(HttpCacheTest, UpdatesRequestResponseTimeOn304) {
MockHttpCache cache;
const char kUrl[] = "http://foobar";
const char kData[] = "body";
MockTransaction mock_network_response = {nullptr};
mock_network_response.url = kUrl;
AddMockTransaction(&mock_network_response);
// Request |kUrl|, causing |kNetResponse1| to be written to the cache.
MockTransaction request = {nullptr};
request.url = kUrl;
request.method = "GET";
request.request_headers = "\r\n";
request.data = kData;
static const Response kNetResponse1 = {
"HTTP/1.1 200 OK",
"Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
kData
};
kNetResponse1.AssignTo(&mock_network_response);
RunTransactionTest(cache.http_cache(), request);
// Request |kUrl| again, this time validating the cache and getting
// a 304 back.
request.load_flags = LOAD_VALIDATE_CACHE;
static const Response kNetResponse2 = {
"HTTP/1.1 304 Not Modified",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n",
""
};
kNetResponse2.AssignTo(&mock_network_response);
base::Time request_time = base::Time() + base::Hours(1234);
base::Time response_time = base::Time() + base::Hours(1235);
mock_network_response.request_time = request_time;
mock_network_response.response_time = response_time;
HttpResponseInfo response;
RunTransactionTestWithResponseInfo(cache.http_cache(), request, &response);
// The request and response times should have been updated.
EXPECT_EQ(request_time.ToInternalValue(),
response.request_time.ToInternalValue());
EXPECT_EQ(response_time.ToInternalValue(),
response.response_time.ToInternalValue());
EXPECT_EQ("HTTP/1.1 200 OK\n"
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
ToSimpleString(response.headers));
RemoveMockTransaction(&mock_network_response);
}
TEST_P(HttpCacheTest_SplitCacheFeatureEnabled,
SplitCacheWithNetworkIsolationKey) {
MockHttpCache cache;
HttpResponseInfo response;
SchemefulSite site_a(GURL("http://a.com"));
SchemefulSite site_b(GURL("http://b.com"));
SchemefulSite site_data(GURL("data:text/html,<body>Hello World</body>"));
MockHttpRequest trans_info = MockHttpRequest(kSimpleGET_Transaction);
// Request with a.com as the top frame and subframe origins. This should
// result in a cache miss.
trans_info.network_isolation_key = NetworkIsolationKey(site_a, site_a);
trans_info.network_anonymization_key =
net::NetworkAnonymizationKey::CreateSameSite(site_a);
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
EXPECT_FALSE(response.was_cached);
// The second request should result in a cache hit.
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
EXPECT_TRUE(response.was_cached);
// Now request with b.com as the subframe origin. It should result in a cache
// miss.
trans_info.network_isolation_key = NetworkIsolationKey(site_a, site_b);
trans_info.network_anonymization_key =
net::NetworkAnonymizationKey::CreateCrossSite(site_a);
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
EXPECT_FALSE(response.was_cached);
// The second request should result in a cache hit.
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
EXPECT_TRUE(response.was_cached);
// Another request with a.com as the top frame and subframe origin should
// still result in a cache hit.
trans_info.network_isolation_key = NetworkIsolationKey(site_a, site_a);
trans_info.network_anonymization_key =
net::NetworkAnonymizationKey::CreateSameSite(site_a);
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
EXPECT_TRUE(response.was_cached);
// Now make a request with an opaque subframe site. It shouldn't cause
// anything to be added to the cache when the NIK makes use of the frame site.
// Note that we will use `site_b` as the top-level site so that this resource
// won't be in the cache at first regardless of the NIK partitioning scheme.
trans_info.network_isolation_key = NetworkIsolationKey(site_b, site_data);
trans_info.network_anonymization_key =
net::NetworkAnonymizationKey::CreateCrossSite(site_b);
if (IsNikFrameSiteEnabled()) {
EXPECT_EQ(absl::nullopt,
trans_info.network_isolation_key.ToCacheKeyString());
} else {
EXPECT_EQ("http://b.com _1",
trans_info.network_isolation_key.ToCacheKeyString().value());
}
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
EXPECT_FALSE(response.was_cached);
// On the second request, expect a cache miss if the NIK uses the frame site.
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
if (IsNikFrameSiteEnabled()) {
EXPECT_FALSE(response.was_cached);
} else {
EXPECT_TRUE(response.was_cached);
}
// Verify that a post transaction with a data stream uses a separate key.
const int64_t kUploadId = 1; // Just a dummy value.
std::vector<std::unique_ptr<UploadElementReader>> element_readers;
element_readers.push_back(
std::make_unique<UploadBytesElementReader>("hello", 5));
ElementsUploadDataStream upload_data_stream(std::move(element_readers),
kUploadId);
MockHttpRequest post_info = MockHttpRequest(kSimplePOST_Transaction);
post_info.network_isolation_key = NetworkIsolationKey(site_a, site_a);
post_info.network_anonymization_key =
net::NetworkAnonymizationKey::CreateSameSite(site_a);
post_info.upload_data_stream = &upload_data_stream;
RunTransactionTestWithRequest(cache.http_cache(), kSimplePOST_Transaction,
post_info, &response);
EXPECT_FALSE(response.was_cached);
}
TEST_F(HttpCacheTest, HttpCacheProfileThirdPartyCSS) {
base::HistogramTester histograms;
MockHttpCache cache;
HttpResponseInfo response;
url::Origin origin_a = url::Origin::Create(GURL(kSimpleGET_Transaction.url));
url::Origin origin_b = url::Origin::Create(GURL("http://b.com"));
SchemefulSite site_a(origin_a);
SchemefulSite site_b(origin_b);
ScopedMockTransaction transaction(kSimpleGET_Transaction);
transaction.response_headers = "Content-Type: text/css\n";
MockHttpRequest trans_info = MockHttpRequest(transaction);
// Requesting with the same top-frame site should not count as third-party
// but should still be recorded as CSS
trans_info.network_isolation_key = NetworkIsolationKey(site_a, site_a);
trans_info.network_anonymization_key =
net::NetworkAnonymizationKey::CreateSameSite(site_a);
trans_info.possibly_top_frame_origin = origin_a;
RunTransactionTestWithRequest(cache.http_cache(), transaction, trans_info,
&response);
histograms.ExpectTotalCount("HttpCache.Pattern", 1);
histograms.ExpectTotalCount("HttpCache.Pattern.CSS", 1);
histograms.ExpectTotalCount("HttpCache.Pattern.CSSThirdParty", 0);
// Requesting with a different top-frame site should count as third-party
// and recorded as CSS
trans_info.network_isolation_key = NetworkIsolationKey(site_b, site_b);
trans_info.network_anonymization_key =
net::NetworkAnonymizationKey::CreateSameSite(site_b);
trans_info.possibly_top_frame_origin = origin_b;
RunTransactionTestWithRequest(cache.http_cache(), transaction, trans_info,
&response);
histograms.ExpectTotalCount("HttpCache.Pattern", 2);
histograms.ExpectTotalCount("HttpCache.Pattern.CSS", 2);
histograms.ExpectTotalCount("HttpCache.Pattern.CSSThirdParty", 1);
}
TEST_F(HttpCacheTest, HttpCacheProfileThirdPartyJavaScript) {
base::HistogramTester histograms;
MockHttpCache cache;
HttpResponseInfo response;
url::Origin origin_a = url::Origin::Create(GURL(kSimpleGET_Transaction.url));
url::Origin origin_b = url::Origin::Create(GURL("http://b.com"));
SchemefulSite site_a(origin_a);
SchemefulSite site_b(origin_b);
ScopedMockTransaction transaction(kSimpleGET_Transaction);
transaction.response_headers = "Content-Type: application/javascript\n";
MockHttpRequest trans_info = MockHttpRequest(transaction);
// Requesting with the same top-frame site should not count as third-party
// but should still be recorded as JavaScript
trans_info.network_isolation_key = NetworkIsolationKey(site_a, site_a);
trans_info.network_anonymization_key =
net::NetworkAnonymizationKey::CreateSameSite(site_a);
trans_info.possibly_top_frame_origin = origin_a;
RunTransactionTestWithRequest(cache.http_cache(), transaction, trans_info,
&response);
histograms.ExpectTotalCount("HttpCache.Pattern", 1);
histograms.ExpectTotalCount("HttpCache.Pattern.JavaScript", 1);
histograms.ExpectTotalCount("HttpCache.Pattern.JavaScriptThirdParty", 0);
// Requesting with a different top-frame site should count as third-party
// and recorded as JavaScript
trans_info.network_isolation_key = NetworkIsolationKey(site_b, site_b);
trans_info.network_anonymization_key =
net::NetworkAnonymizationKey::CreateSameSite(site_b);
trans_info.possibly_top_frame_origin = origin_b;
RunTransactionTestWithRequest(cache.http_cache(), transaction, trans_info,
&response);
histograms.ExpectTotalCount("HttpCache.Pattern", 2);
histograms.ExpectTotalCount("HttpCache.Pattern.JavaScript", 2);
histograms.ExpectTotalCount("HttpCache.Pattern.JavaScriptThirdParty", 1);
}
TEST_F(HttpCacheTest, HttpCacheProfileThirdPartyFont) {
base::HistogramTester histograms;
MockHttpCache cache;
HttpResponseInfo response;
url::Origin origin_a = url::Origin::Create(GURL(kSimpleGET_Transaction.url));
url::Origin origin_b = url::Origin::Create(GURL("http://b.com"));
SchemefulSite site_a(origin_a);
SchemefulSite site_b(origin_b);
ScopedMockTransaction transaction(kSimpleGET_Transaction);
transaction.response_headers = "Content-Type: font/otf\n";
MockHttpRequest trans_info = MockHttpRequest(transaction);
// Requesting with the same top-frame site should not count as third-party
// but should still be recorded as a font
trans_info.network_isolation_key = NetworkIsolationKey(site_a, site_a);
trans_info.network_anonymization_key =
net::NetworkAnonymizationKey::CreateSameSite(site_a);
trans_info.possibly_top_frame_origin = origin_a;
RunTransactionTestWithRequest(cache.http_cache(), transaction, trans_info,
&response);
histograms.ExpectTotalCount("HttpCache.Pattern", 1);
histograms.ExpectTotalCount("HttpCache.Pattern.Font", 1);
histograms.ExpectTotalCount("HttpCache.Pattern.FontThirdParty", 0);
// Requesting with a different top-frame site should count as third-party
// and recorded as a font
trans_info.network_isolation_key = NetworkIsolationKey(site_b, site_b);
trans_info.network_anonymization_key =
net::NetworkAnonymizationKey::CreateSameSite(site_b);
trans_info.possibly_top_frame_origin = origin_b;
RunTransactionTestWithRequest(cache.http_cache(), transaction, trans_info,
&response);
histograms.ExpectTotalCount("HttpCache.Pattern", 2);
histograms.ExpectTotalCount("HttpCache.Pattern.Font", 2);
histograms.ExpectTotalCount("HttpCache.Pattern.FontThirdParty", 1);
}
TEST_P(HttpCacheTest_SplitCacheFeatureEnabled, SplitCache) {
MockHttpCache cache;
HttpResponseInfo response;
SchemefulSite site_a(GURL("http://a.com"));
SchemefulSite site_b(GURL("http://b.com"));
SchemefulSite site_data(GURL("data:text/html,<body>Hello World</body>"));
// A request without a top frame origin shouldn't result in anything being
// added to the cache.
MockHttpRequest trans_info = MockHttpRequest(kSimpleGET_Transaction);
trans_info.network_isolation_key = net::NetworkIsolationKey();
trans_info.network_anonymization_key = net::NetworkAnonymizationKey();
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
EXPECT_FALSE(response.was_cached);
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
EXPECT_FALSE(response.was_cached);
// Now request with a.com as the top frame origin. This should initially
// result in a cache miss since the cached resource has a different top frame
// origin.
net::NetworkIsolationKey key_a(site_a, site_a);
auto nak_a = net::NetworkAnonymizationKey::CreateSameSite(site_a);
trans_info.network_isolation_key = key_a;
trans_info.network_anonymization_key = nak_a;
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
EXPECT_FALSE(response.was_cached);
// The second request should result in a cache hit.
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
EXPECT_TRUE(response.was_cached);
// If the same resource with the same NIK is for a subframe document resource,
// it should not be a cache hit.
MockHttpRequest subframe_document_trans_info = trans_info;
subframe_document_trans_info.is_subframe_document_resource = true;
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
subframe_document_trans_info, &response);
EXPECT_FALSE(response.was_cached);
// Same request again should be a cache hit.
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
subframe_document_trans_info, &response);
EXPECT_TRUE(response.was_cached);
// Now request with b.com as the top frame origin. It should be a cache miss.
trans_info.network_isolation_key = NetworkIsolationKey(site_b, site_b);
trans_info.network_anonymization_key =
NetworkAnonymizationKey::CreateSameSite(site_b);
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
EXPECT_FALSE(response.was_cached);
// The second request should be a cache hit.
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
EXPECT_TRUE(response.was_cached);
// Another request for a.com should still result in a cache hit.
trans_info.network_isolation_key = key_a;
trans_info.network_anonymization_key = nak_a;
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
EXPECT_TRUE(response.was_cached);
// Now make a request with an opaque top frame origin. It shouldn't result in
// a cache hit.
trans_info.network_isolation_key = NetworkIsolationKey(site_data, site_data);
trans_info.network_anonymization_key =
NetworkAnonymizationKey::CreateSameSite(site_data);
EXPECT_EQ(absl::nullopt, trans_info.network_isolation_key.ToCacheKeyString());
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
EXPECT_FALSE(response.was_cached);
// On the second request, it still shouldn't result in a cache hit.
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
EXPECT_FALSE(response.was_cached);
// Verify that a post transaction with a data stream uses a separate key.
const int64_t kUploadId = 1; // Just a dummy value.
std::vector<std::unique_ptr<UploadElementReader>> element_readers;
element_readers.push_back(
std::make_unique<UploadBytesElementReader>("hello", 5));
ElementsUploadDataStream upload_data_stream(std::move(element_readers),
kUploadId);
MockHttpRequest post_info = MockHttpRequest(kSimplePOST_Transaction);
post_info.network_isolation_key = NetworkIsolationKey(site_a, site_a);
post_info.network_anonymization_key =
NetworkAnonymizationKey::CreateSameSite(site_a);
post_info.upload_data_stream = &upload_data_stream;
RunTransactionTestWithRequest(cache.http_cache(), kSimplePOST_Transaction,
post_info, &response);
EXPECT_FALSE(response.was_cached);
}
TEST_F(HttpCacheTest, SplitCacheEnabledByDefault) {
HttpCache::ClearGlobalsForTesting();
HttpCache::SplitCacheFeatureEnableByDefault();
EXPECT_TRUE(HttpCache::IsSplitCacheEnabled());
MockHttpCache cache;
HttpResponseInfo response;
SchemefulSite site_a(GURL("http://a.com"));
SchemefulSite site_b(GURL("http://b.com"));
MockHttpRequest trans_info = MockHttpRequest(kSimpleGET_Transaction);
net::NetworkIsolationKey key_a(site_a, site_a);
auto nak_a = net::NetworkAnonymizationKey::CreateSameSite(site_a);
trans_info.network_isolation_key = key_a;
trans_info.network_anonymization_key = nak_a;
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
EXPECT_FALSE(response.was_cached);
// Subsequent requests with the same NIK and different NIK will be a cache hit
// and miss respectively.
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
EXPECT_TRUE(response.was_cached);
net::NetworkIsolationKey key_b(site_b, site_b);
auto nak_b = net::NetworkAnonymizationKey::CreateSameSite(site_b);
trans_info.network_isolation_key = key_b;
trans_info.network_anonymization_key = nak_b;
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
EXPECT_FALSE(response.was_cached);
}
TEST_F(HttpCacheTest, SplitCacheEnabledByDefaultButOverridden) {
HttpCache::ClearGlobalsForTesting();
base::test::ScopedFeatureList feature_list;
feature_list.InitAndDisableFeature(
net::features::kSplitCacheByNetworkIsolationKey);
// Enabling it here should have no effect as it is already overridden.
HttpCache::SplitCacheFeatureEnableByDefault();
EXPECT_FALSE(HttpCache::IsSplitCacheEnabled());
}
TEST_P(HttpCacheTest_SplitCacheFeatureEnabled,
SplitCacheUsesRegistrableDomain) {
MockHttpCache cache;
HttpResponseInfo response;
MockHttpRequest trans_info = MockHttpRequest(kSimpleGET_Transaction);
SchemefulSite site_a(GURL("http://a.foo.com"));
SchemefulSite site_b(GURL("http://b.foo.com"));
net::NetworkIsolationKey key_a(site_a, site_a);
auto nak_a = net::NetworkAnonymizationKey::CreateSameSite(site_a);
trans_info.network_isolation_key = key_a;
trans_info.network_anonymization_key = nak_a;
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
EXPECT_FALSE(response.was_cached);
// The second request with a different origin but the same registrable domain
// should be a cache hit.
net::NetworkIsolationKey key_b(site_b, site_b);
auto nak_b = net::NetworkAnonymizationKey::CreateSameSite(site_b);
trans_info.network_isolation_key = key_b;
trans_info.network_anonymization_key = nak_b;
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
EXPECT_TRUE(response.was_cached);
// Request with a different registrable domain. It should be a cache miss.
SchemefulSite new_site_a(GURL("http://a.bar.com"));
net::NetworkIsolationKey new_key_a(new_site_a, new_site_a);
auto new_nak_a = net::NetworkAnonymizationKey::CreateSameSite(new_site_a);
trans_info.network_isolation_key = new_key_a;
trans_info.network_anonymization_key = new_nak_a;
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
EXPECT_FALSE(response.was_cached);
}
TEST_F(HttpCacheTest, NonSplitCache) {
base::test::ScopedFeatureList feature_list;
feature_list.InitAndDisableFeature(
net::features::kSplitCacheByNetworkIsolationKey);
MockHttpCache cache;
HttpResponseInfo response;
// A request without a top frame is added to the cache normally.
MockHttpRequest trans_info = MockHttpRequest(kSimpleGET_Transaction);
trans_info.network_isolation_key = NetworkIsolationKey();
trans_info.network_anonymization_key = NetworkAnonymizationKey();
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
EXPECT_FALSE(response.was_cached);
// The second request should result in a cache hit.
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
EXPECT_TRUE(response.was_cached);
// Now request with a.com as the top frame origin. The same cached object
// should be used.
const SchemefulSite kSiteA(GURL("http://a.com/"));
trans_info.network_isolation_key = NetworkIsolationKey(kSiteA, kSiteA);
trans_info.network_anonymization_key =
NetworkAnonymizationKey::CreateSameSite(kSiteA);
RunTransactionTestWithRequest(cache.http_cache(), kSimpleGET_Transaction,
trans_info, &response);
EXPECT_TRUE(response.was_cached);
}
TEST_F(HttpCacheTest, SkipVaryCheck) {
MockHttpCache cache;
// Write a simple vary transaction to the cache.
HttpResponseInfo response;
ScopedMockTransaction transaction(kSimpleGET_Transaction);
transaction.request_headers = "accept-encoding: gzip\r\n";
transaction.response_headers =
"Vary: accept-encoding\n"
"Cache-Control: max-age=10000\n";
RunTransactionTest(cache.http_cache(), transaction);
// Change the request headers so that the request doesn't match due to vary.
// The request should fail.
transaction.load_flags = LOAD_ONLY_FROM_CACHE;
transaction.request_headers = "accept-encoding: foo\r\n";
transaction.start_return_code = ERR_CACHE_MISS;
RunTransactionTest(cache.http_cache(), transaction);
// Change the load flags to ignore vary checks, the request should now hit.
transaction.load_flags = LOAD_ONLY_FROM_CACHE | LOAD_SKIP_VARY_CHECK;
transaction.start_return_code = OK;
RunTransactionTest(cache.http_cache(), transaction);
}
TEST_F(HttpCacheTest, SkipVaryCheckStar) {
MockHttpCache cache;
// Write a simple vary:* transaction to the cache.
HttpResponseInfo response;
ScopedMockTransaction transaction(kSimpleGET_Transaction);
transaction.request_headers = "accept-encoding: gzip\r\n";
transaction.response_headers =
"Vary: *\n"
"Cache-Control: max-age=10000\n";
RunTransactionTest(cache.http_cache(), transaction);
// The request shouldn't match even with the same request headers due to the
// Vary: *. The request should fail.
transaction.load_flags = LOAD_ONLY_FROM_CACHE;
transaction.start_return_code = ERR_CACHE_MISS;
RunTransactionTest(cache.http_cache(), transaction);
// Change the load flags to ignore vary checks, the request should now hit.
transaction.load_flags = LOAD_ONLY_FROM_CACHE | LOAD_SKIP_VARY_CHECK;
transaction.start_return_code = OK;
RunTransactionTest(cache.http_cache(), transaction);
}
// Tests that we only return valid entries with LOAD_ONLY_FROM_CACHE
// transactions unless LOAD_SKIP_CACHE_VALIDATION is set.
TEST_F(HttpCacheTest, ValidLoadOnlyFromCache) {
MockHttpCache cache;
base::SimpleTestClock clock;
cache.http_cache()->SetClockForTesting(&clock);
cache.network_layer()->SetClock(&clock);
// Write a resource that will expire in 100 seconds.
ScopedMockTransaction transaction(kSimpleGET_Transaction);
transaction.response_headers = "Cache-Control: max-age=100\n";
RunTransactionTest(cache.http_cache(), transaction);
// Move forward in time such that the cached response is no longer valid.
clock.Advance(base::Seconds(101));
// Skipping cache validation should still return a response.
transaction.load_flags = LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
RunTransactionTest(cache.http_cache(), transaction);
// If the cache entry is checked for validitiy, it should fail.
transaction.load_flags = LOAD_ONLY_FROM_CACHE;
transaction.start_return_code = ERR_CACHE_MISS;
RunTransactionTest(cache.http_cache(), transaction);
}
TEST_F(HttpCacheTest, InvalidLoadFlagCombination) {
MockHttpCache cache;
// Put the resource in the cache.
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
// Now try to fetch it again, but with a flag combination disallowing both
// cache and network access.
ScopedMockTransaction transaction(kSimpleGET_Transaction);
// DevTools relies on this combination of flags for "disable cache" mode
// when a resource is only supposed to be loaded from cache.
transaction.load_flags = LOAD_ONLY_FROM_CACHE | LOAD_BYPASS_CACHE;
transaction.start_return_code = ERR_CACHE_MISS;
RunTransactionTest(cache.http_cache(), transaction);
}
// Tests that we don't mark entries as truncated when a filter detects the end
// of the stream.
TEST_F(HttpCacheTest, FilterCompletion) {
MockHttpCache cache;
TestCompletionCallback callback;
{
MockHttpRequest request(kSimpleGET_Transaction);
std::unique_ptr<HttpTransaction> trans;
ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
EXPECT_THAT(callback.GetResult(rv), IsOk());
scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(256);
rv = trans->Read(buf.get(), 256, callback.callback());
EXPECT_GT(callback.GetResult(rv), 0);
// Now make sure that the entry is preserved.
trans->DoneReading();
}
// Make sure that the ActiveEntry is gone.
base::RunLoop().RunUntilIdle();
// Read from the cache.
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Tests that we don't mark entries as truncated and release the cache
// entry when DoneReading() is called before any Read() calls, such as
// for a redirect.
TEST_F(HttpCacheTest, DoneReading) {
MockHttpCache cache;
TestCompletionCallback callback;
ScopedMockTransaction transaction(kSimpleGET_Transaction);
transaction.data = "";
MockHttpRequest request(transaction);
std::unique_ptr<HttpTransaction> trans;
ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
EXPECT_THAT(callback.GetResult(rv), IsOk());
trans->DoneReading();
// Leave the transaction around.
// Make sure that the ActiveEntry is gone.
base::RunLoop().RunUntilIdle();
// Read from the cache. This should not deadlock.
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Tests that we stop caching when told.
TEST_F(HttpCacheTest, StopCachingDeletesEntry) {
MockHttpCache cache;
TestCompletionCallback callback;
MockHttpRequest request(kSimpleGET_Transaction);
{
std::unique_ptr<HttpTransaction> trans;
ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
EXPECT_THAT(callback.GetResult(rv), IsOk());
scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(256);
rv = trans->Read(buf.get(), 10, callback.callback());
EXPECT_EQ(10, callback.GetResult(rv));
trans->StopCaching();
// We should be able to keep reading.
rv = trans->Read(buf.get(), 256, callback.callback());
EXPECT_GT(callback.GetResult(rv), 0);
rv = trans->Read(buf.get(), 256, callback.callback());
EXPECT_EQ(0, callback.GetResult(rv));
}
// Make sure that the ActiveEntry is gone.
base::RunLoop().RunUntilIdle();
// Verify that the entry is gone.
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests that we stop caching when told, even if DoneReading is called
// after StopCaching.
TEST_F(HttpCacheTest, StopCachingThenDoneReadingDeletesEntry) {
MockHttpCache cache;
TestCompletionCallback callback;
MockHttpRequest request(kSimpleGET_Transaction);
{
std::unique_ptr<HttpTransaction> trans;
ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
EXPECT_THAT(callback.GetResult(rv), IsOk());
scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(256);
rv = trans->Read(buf.get(), 10, callback.callback());
EXPECT_EQ(10, callback.GetResult(rv));
trans->StopCaching();
// We should be able to keep reading.
rv = trans->Read(buf.get(), 256, callback.callback());
EXPECT_GT(callback.GetResult(rv), 0);
rv = trans->Read(buf.get(), 256, callback.callback());
EXPECT_EQ(0, callback.GetResult(rv));
// We should be able to call DoneReading.
trans->DoneReading();
}
// Make sure that the ActiveEntry is gone.
base::RunLoop().RunUntilIdle();
// Verify that the entry is gone.
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests that we stop caching when told, when using auth.
TEST_F(HttpCacheTest, StopCachingWithAuthDeletesEntry) {
MockHttpCache cache;
TestCompletionCallback callback;
MockTransaction mock_transaction(kSimpleGET_Transaction);
mock_transaction.status = "HTTP/1.1 401 Unauthorized";
AddMockTransaction(&mock_transaction);
MockHttpRequest request(mock_transaction);
{
std::unique_ptr<HttpTransaction> trans;
ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
EXPECT_THAT(callback.GetResult(rv), IsOk());
trans->StopCaching();
}
RemoveMockTransaction(&mock_transaction);
// Make sure that the ActiveEntry is gone.
base::RunLoop().RunUntilIdle();
// Verify that the entry is gone.
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests that when we are told to stop caching we don't throw away valid data.
TEST_F(HttpCacheTest, StopCachingSavesEntry) {
MockHttpCache cache;
TestCompletionCallback callback;
MockHttpRequest request(kSimpleGET_Transaction);
{
std::unique_ptr<HttpTransaction> trans;
ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
// Force a response that can be resumed.
ScopedMockTransaction mock_transaction(kSimpleGET_Transaction);
AddMockTransaction(&mock_transaction);
mock_transaction.response_headers = "Cache-Control: max-age=10000\n"
"Content-Length: 42\n"
"Etag: \"foo\"\n";
int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
EXPECT_THAT(callback.GetResult(rv), IsOk());
scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(256);
rv = trans->Read(buf.get(), 10, callback.callback());
EXPECT_EQ(callback.GetResult(rv), 10);
trans->StopCaching();
// We should be able to keep reading.
rv = trans->Read(buf.get(), 256, callback.callback());
EXPECT_GT(callback.GetResult(rv), 0);
rv = trans->Read(buf.get(), 256, callback.callback());
EXPECT_EQ(callback.GetResult(rv), 0);
}
// Verify that the entry is marked as incomplete.
// VerifyTruncatedFlag(&cache, kSimpleGET_Transaction.url, true, 0);
// Verify that the entry is doomed.
cache.disk_cache()->IsDiskEntryDoomed(request.CacheKey());
}
// Tests that we handle truncated enries when StopCaching is called.
TEST_F(HttpCacheTest, StopCachingTruncatedEntry) {
MockHttpCache cache;
TestCompletionCallback callback;
MockHttpRequest request(kRangeGET_TransactionOK);
request.extra_headers.Clear();
request.extra_headers.AddHeaderFromString(EXTRA_HEADER_LINE);
AddMockTransaction(&kRangeGET_TransactionOK);
std::string raw_headers("HTTP/1.1 200 OK\n"
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
"Content-Length: 80\n");
CreateTruncatedEntry(raw_headers, &cache);
{
// Now make a regular request.
std::unique_ptr<HttpTransaction> trans;
ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
EXPECT_THAT(callback.GetResult(rv), IsOk());
scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(256);
rv = trans->Read(buf.get(), 10, callback.callback());
EXPECT_EQ(callback.GetResult(rv), 10);
// This is actually going to do nothing.
trans->StopCaching();
// We should be able to keep reading.
rv = trans->Read(buf.get(), 256, callback.callback());
EXPECT_GT(callback.GetResult(rv), 0);
rv = trans->Read(buf.get(), 256, callback.callback());
EXPECT_GT(callback.GetResult(rv), 0);
rv = trans->Read(buf.get(), 256, callback.callback());
EXPECT_EQ(callback.GetResult(rv), 0);
}
// Verify that the disk entry was updated.
VerifyTruncatedFlag(&cache, request.CacheKey(), false, 80);
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
namespace {
enum class TransactionPhase {
BEFORE_FIRST_READ,
AFTER_FIRST_READ,
AFTER_NETWORK_READ
};
using CacheInitializer = void (*)(MockHttpCache*);
using HugeCacheTestConfiguration =
std::pair<TransactionPhase, CacheInitializer>;
class HttpCacheHugeResourceTest
: public ::testing::TestWithParam<HugeCacheTestConfiguration>,
public WithTaskEnvironment {
public:
static std::list<HugeCacheTestConfiguration> GetTestModes();
static std::list<HugeCacheTestConfiguration> kTestModes;
// CacheInitializer callbacks. These are used to initialize the cache
// depending on the test run configuration.
// Initializes a cache containing a truncated entry containing the first 20
// bytes of the reponse body.
static void SetupTruncatedCacheEntry(MockHttpCache* cache);
// Initializes a cache containing a sparse entry. The first 10 bytes are
// present in the cache.
static void SetupPrefixSparseCacheEntry(MockHttpCache* cache);
// Initializes a cache containing a sparse entry. The 10 bytes at offset
// 99990 are present in the cache.
static void SetupInfixSparseCacheEntry(MockHttpCache* cache);
protected:
static void LargeResourceTransactionHandler(
const net::HttpRequestInfo* request,
std::string* response_status,
std::string* response_headers,
std::string* response_data);
static int LargeBufferReader(int64_t content_length,
int64_t offset,
net::IOBuffer* buf,
int buf_len);
static void SetFlagOnBeforeNetworkStart(bool* started, bool* /* defer */);
// Size of resource to be tested.
static const int64_t kTotalSize = 5000LL * 1000 * 1000;
};
const int64_t HttpCacheHugeResourceTest::kTotalSize;
// static
void HttpCacheHugeResourceTest::LargeResourceTransactionHandler(
const net::HttpRequestInfo* request,
std::string* response_status,
std::string* response_headers,
std::string* response_data) {
std::string if_range;
if (!request->extra_headers.GetHeader(net::HttpRequestHeaders::kIfRange,
&if_range)) {
// If there were no range headers in the request, we are going to just
// return the entire response body.
*response_status = "HTTP/1.1 200 Success";
*response_headers = base::StringPrintf("Content-Length: %" PRId64
"\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n",
kTotalSize);
return;
}
// From this point on, we should be processing a valid byte-range request.
EXPECT_EQ("\"foo\"", if_range);
std::string range_header;
EXPECT_TRUE(request->extra_headers.GetHeader(net::HttpRequestHeaders::kRange,
&range_header));
std::vector<net::HttpByteRange> ranges;
EXPECT_TRUE(net::HttpUtil::ParseRangeHeader(range_header, &ranges));
ASSERT_EQ(1u, ranges.size());
net::HttpByteRange range = ranges[0];
EXPECT_TRUE(range.HasFirstBytePosition());
int64_t last_byte_position =
range.HasLastBytePosition() ? range.last_byte_position() : kTotalSize - 1;
*response_status = "HTTP/1.1 206 Partial";
*response_headers = base::StringPrintf(
"Content-Range: bytes %" PRId64 "-%" PRId64 "/%" PRId64
"\n"
"Content-Length: %" PRId64 "\n",
range.first_byte_position(), last_byte_position, kTotalSize,
last_byte_position - range.first_byte_position() + 1);
}
// static
int HttpCacheHugeResourceTest::LargeBufferReader(int64_t content_length,
int64_t offset,
net::IOBuffer* buf,
int buf_len) {
// This test involves reading multiple gigabytes of data. To make it run in a
// reasonable amount of time, we are going to skip filling the buffer with
// data. Instead the test relies on verifying that the count of bytes expected
// at the end is correct.
EXPECT_LT(0, content_length);
EXPECT_LE(offset, content_length);
int num = std::min(static_cast<int64_t>(buf_len), content_length - offset);
return num;
}
// static
void HttpCacheHugeResourceTest::SetFlagOnBeforeNetworkStart(bool* started,
bool* /* defer */) {
*started = true;
}
// static
void HttpCacheHugeResourceTest::SetupTruncatedCacheEntry(MockHttpCache* cache) {
ScopedMockTransaction scoped_transaction(kRangeGET_TransactionOK);
std::string cached_headers = base::StringPrintf(
"HTTP/1.1 200 OK\n"
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
"Content-Length: %" PRId64 "\n",
kTotalSize);
CreateTruncatedEntry(cached_headers, cache);
}
// static
void HttpCacheHugeResourceTest::SetupPrefixSparseCacheEntry(
MockHttpCache* cache) {
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.handler = nullptr;
transaction.request_headers = "Range: bytes = 0-9\r\n" EXTRA_HEADER;
transaction.response_headers =
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
"Content-Range: bytes 0-9/5000000000\n"
"Content-Length: 10\n";
AddMockTransaction(&transaction);
std::string headers;
RunTransactionTestWithResponse(cache->http_cache(), transaction, &headers);
RemoveMockTransaction(&transaction);
}
// static
void HttpCacheHugeResourceTest::SetupInfixSparseCacheEntry(
MockHttpCache* cache) {
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.handler = nullptr;
transaction.request_headers = "Range: bytes = 99990-99999\r\n" EXTRA_HEADER;
transaction.response_headers =
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
"Content-Range: bytes 99990-99999/5000000000\n"
"Content-Length: 10\n";
AddMockTransaction(&transaction);
std::string headers;
RunTransactionTestWithResponse(cache->http_cache(), transaction, &headers);
RemoveMockTransaction(&transaction);
}
// static
std::list<HugeCacheTestConfiguration>
HttpCacheHugeResourceTest::GetTestModes() {
std::list<HugeCacheTestConfiguration> test_modes;
const TransactionPhase kTransactionPhases[] = {
TransactionPhase::BEFORE_FIRST_READ, TransactionPhase::AFTER_FIRST_READ,
TransactionPhase::AFTER_NETWORK_READ};
const CacheInitializer kInitializers[] = {&SetupTruncatedCacheEntry,
&SetupPrefixSparseCacheEntry,
&SetupInfixSparseCacheEntry};
for (const auto phase : kTransactionPhases)
for (const auto initializer : kInitializers)
test_modes.emplace_back(phase, initializer);
return test_modes;
}
// static
std::list<HugeCacheTestConfiguration> HttpCacheHugeResourceTest::kTestModes =
HttpCacheHugeResourceTest::GetTestModes();
INSTANTIATE_TEST_SUITE_P(
_,
HttpCacheHugeResourceTest,
::testing::ValuesIn(HttpCacheHugeResourceTest::kTestModes));
} // namespace
// Test what happens when StopCaching() is called while reading a huge resource
// fetched via GET. Various combinations of cache state and when StopCaching()
// is called is controlled by the parameter passed into the test via the
// INSTANTIATE_TEST_SUITE_P invocation above.
TEST_P(HttpCacheHugeResourceTest,
StopCachingFollowedByReadForHugeTruncatedResource) {
// This test is going to be repeated for all combinations of TransactionPhase
// and CacheInitializers returned by GetTestModes().
const TransactionPhase stop_caching_phase = GetParam().first;
const CacheInitializer cache_initializer = GetParam().second;
MockHttpCache cache;
(*cache_initializer)(&cache);
MockTransaction transaction(kSimpleGET_Transaction);
transaction.url = kRangeGET_TransactionOK.url;
transaction.handler = &LargeResourceTransactionHandler;
transaction.read_handler = &LargeBufferReader;
ScopedMockTransaction scoped_transaction(transaction);
MockHttpRequest request(transaction);
net::TestCompletionCallback callback;
std::unique_ptr<net::HttpTransaction> http_transaction;
int rv = cache.http_cache()->CreateTransaction(net::DEFAULT_PRIORITY,
&http_transaction);
ASSERT_EQ(net::OK, rv);
ASSERT_TRUE(http_transaction.get());
bool network_transaction_started = false;
if (stop_caching_phase == TransactionPhase::AFTER_NETWORK_READ) {
http_transaction->SetBeforeNetworkStartCallback(base::BindOnce(
&SetFlagOnBeforeNetworkStart, &network_transaction_started));
}
rv = http_transaction->Start(&request, callback.callback(),
NetLogWithSource());
rv = callback.GetResult(rv);
ASSERT_EQ(net::OK, rv);
if (stop_caching_phase == TransactionPhase::BEFORE_FIRST_READ)
http_transaction->StopCaching();
int64_t total_bytes_received = 0;
EXPECT_EQ(kTotalSize,
http_transaction->GetResponseInfo()->headers->GetContentLength());
do {
// This test simulates reading gigabytes of data. Buffer size is set to 10MB
// to reduce the number of reads and speed up the test.
const int kBufferSize = 1024 * 1024 * 10;
scoped_refptr<net::IOBuffer> buf =
base::MakeRefCounted<net::IOBuffer>(kBufferSize);
rv = http_transaction->Read(buf.get(), kBufferSize, callback.callback());
rv = callback.GetResult(rv);
if (stop_caching_phase == TransactionPhase::AFTER_FIRST_READ &&
total_bytes_received == 0) {
http_transaction->StopCaching();
}
if (rv > 0)
total_bytes_received += rv;
if (network_transaction_started &&
stop_caching_phase == TransactionPhase::AFTER_NETWORK_READ) {
http_transaction->StopCaching();
network_transaction_started = false;
}
} while (rv > 0);
// The only verification we are going to do is that the received resource has
// the correct size. This is sufficient to verify that the state machine
// didn't terminate abruptly due to the StopCaching() call.
EXPECT_EQ(kTotalSize, total_bytes_received);
}
// Tests that we detect truncated resources from the net when there is
// a Content-Length header.
TEST_F(HttpCacheTest, TruncatedByContentLength) {
MockHttpCache cache;
TestCompletionCallback callback;
MockTransaction transaction(kSimpleGET_Transaction);
AddMockTransaction(&transaction);
transaction.response_headers = "Cache-Control: max-age=10000\n"
"Content-Length: 100\n";
RunTransactionTest(cache.http_cache(), transaction);
RemoveMockTransaction(&transaction);
// Read from the cache.
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// Tests that we actually flag entries as truncated when we detect an error
// from the net.
TEST_F(HttpCacheTest, TruncatedByContentLength2) {
MockHttpCache cache;
TestCompletionCallback callback;
MockTransaction transaction(kSimpleGET_Transaction);
AddMockTransaction(&transaction);
transaction.response_headers = "Cache-Control: max-age=10000\n"
"Content-Length: 100\n"
"Etag: \"foo\"\n";
RunTransactionTest(cache.http_cache(), transaction);
RemoveMockTransaction(&transaction);
// Verify that the entry is marked as incomplete.
MockHttpRequest request(transaction);
VerifyTruncatedFlag(&cache, request.CacheKey(), true, 0);
}
// Make sure that calling SetPriority on a cache transaction passes on
// its priority updates to its underlying network transaction.
TEST_F(HttpCacheTest, SetPriority) {
MockHttpCache cache;
HttpRequestInfo info;
std::unique_ptr<HttpTransaction> trans;
ASSERT_THAT(cache.http_cache()->CreateTransaction(IDLE, &trans), IsOk());
// Shouldn't crash, but doesn't do anything either.
trans->SetPriority(LOW);
EXPECT_FALSE(cache.network_layer()->last_transaction());
EXPECT_EQ(DEFAULT_PRIORITY,
cache.network_layer()->last_create_transaction_priority());
info.url = GURL(kSimpleGET_Transaction.url);
TestCompletionCallback callback;
EXPECT_EQ(ERR_IO_PENDING,
trans->Start(&info, callback.callback(), NetLogWithSource()));
EXPECT_TRUE(cache.network_layer()->last_transaction());
if (cache.network_layer()->last_transaction()) {
EXPECT_EQ(LOW, cache.network_layer()->last_create_transaction_priority());
EXPECT_EQ(LOW, cache.network_layer()->last_transaction()->priority());
}
trans->SetPriority(HIGHEST);
if (cache.network_layer()->last_transaction()) {
EXPECT_EQ(LOW, cache.network_layer()->last_create_transaction_priority());
EXPECT_EQ(HIGHEST, cache.network_layer()->last_transaction()->priority());
}
EXPECT_THAT(callback.WaitForResult(), IsOk());
}
// Make sure that calling SetWebSocketHandshakeStreamCreateHelper on a cache
// transaction passes on its argument to the underlying network transaction.
TEST_F(HttpCacheTest, SetWebSocketHandshakeStreamCreateHelper) {
MockHttpCache cache;
HttpRequestInfo info;
FakeWebSocketHandshakeStreamCreateHelper create_helper;
std::unique_ptr<HttpTransaction> trans;
ASSERT_THAT(cache.http_cache()->CreateTransaction(IDLE, &trans), IsOk());
EXPECT_FALSE(cache.network_layer()->last_transaction());
info.url = GURL(kSimpleGET_Transaction.url);
TestCompletionCallback callback;
EXPECT_EQ(ERR_IO_PENDING,
trans->Start(&info, callback.callback(), NetLogWithSource()));
ASSERT_TRUE(cache.network_layer()->last_transaction());
EXPECT_FALSE(cache.network_layer()->last_transaction()->
websocket_handshake_stream_create_helper());
trans->SetWebSocketHandshakeStreamCreateHelper(&create_helper);
EXPECT_EQ(&create_helper,
cache.network_layer()->last_transaction()->
websocket_handshake_stream_create_helper());
EXPECT_THAT(callback.WaitForResult(), IsOk());
}
// Make sure that a cache transaction passes on its priority to
// newly-created network transactions.
TEST_F(HttpCacheTest, SetPriorityNewTransaction) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
std::string raw_headers("HTTP/1.1 200 OK\n"
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
"Content-Length: 80\n");
CreateTruncatedEntry(raw_headers, &cache);
// Now make a regular request.
std::string headers;
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = EXTRA_HEADER;
transaction.data = kFullRangeData;
std::unique_ptr<HttpTransaction> trans;
ASSERT_THAT(cache.http_cache()->CreateTransaction(MEDIUM, &trans), IsOk());
EXPECT_EQ(DEFAULT_PRIORITY,
cache.network_layer()->last_create_transaction_priority());
MockHttpRequest info(transaction);
TestCompletionCallback callback;
EXPECT_EQ(ERR_IO_PENDING,
trans->Start(&info, callback.callback(), NetLogWithSource()));
EXPECT_THAT(callback.WaitForResult(), IsOk());
EXPECT_EQ(MEDIUM, cache.network_layer()->last_create_transaction_priority());
trans->SetPriority(HIGHEST);
// Should trigger a new network transaction and pick up the new
// priority.
ReadAndVerifyTransaction(trans.get(), transaction);
EXPECT_EQ(HIGHEST, cache.network_layer()->last_create_transaction_priority());
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
namespace {
void RunTransactionAndGetNetworkBytes(MockHttpCache* cache,
const MockTransaction& trans_info,
int64_t* sent_bytes,
int64_t* received_bytes) {
RunTransactionTestBase(
cache->http_cache(), trans_info, MockHttpRequest(trans_info), nullptr,
NetLogWithSource(), nullptr, sent_bytes, received_bytes, nullptr);
}
} // namespace
TEST_F(HttpCacheTest, NetworkBytesCacheMissAndThenHit) {
MockHttpCache cache;
MockTransaction transaction(kSimpleGET_Transaction);
int64_t sent, received;
RunTransactionAndGetNetworkBytes(&cache, transaction, &sent, &received);
EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes, sent);
EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes, received);
RunTransactionAndGetNetworkBytes(&cache, transaction, &sent, &received);
EXPECT_EQ(0, sent);
EXPECT_EQ(0, received);
}
TEST_F(HttpCacheTest, NetworkBytesConditionalRequest304) {
MockHttpCache cache;
ScopedMockTransaction transaction(kETagGET_Transaction);
int64_t sent, received;
RunTransactionAndGetNetworkBytes(&cache, transaction, &sent, &received);
EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes, sent);
EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes, received);
transaction.load_flags = LOAD_VALIDATE_CACHE;
transaction.handler = ETagGet_ConditionalRequest_Handler;
RunTransactionAndGetNetworkBytes(&cache, transaction, &sent, &received);
EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes, sent);
EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes, received);
}
TEST_F(HttpCacheTest, NetworkBytesConditionalRequest200) {
MockHttpCache cache;
MockTransaction transaction(kTypicalGET_Transaction);
transaction.request_headers = "Foo: bar\r\n";
transaction.response_headers =
"Date: Wed, 28 Nov 2007 09:40:09 GMT\n"
"Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
"Etag: \"foopy\"\n"
"Cache-Control: max-age=0\n"
"Vary: Foo\n";
AddMockTransaction(&transaction);
int64_t sent, received;
RunTransactionAndGetNetworkBytes(&cache, transaction, &sent, &received);
EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes, sent);
EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes, received);
RevalidationServer server;
transaction.handler = server.Handler;
transaction.request_headers = "Foo: none\r\n";
RunTransactionAndGetNetworkBytes(&cache, transaction, &sent, &received);
EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes, sent);
EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes, received);
RemoveMockTransaction(&transaction);
}
TEST_F(HttpCacheTest, NetworkBytesRange) {
MockHttpCache cache;
AddMockTransaction(&kRangeGET_TransactionOK);
MockTransaction transaction(kRangeGET_TransactionOK);
// Read bytes 40-49 from the network.
int64_t sent, received;
RunTransactionAndGetNetworkBytes(&cache, transaction, &sent, &received);
EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes, sent);
EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes, received);
// Read bytes 40-49 from the cache.
RunTransactionAndGetNetworkBytes(&cache, transaction, &sent, &received);
EXPECT_EQ(0, sent);
EXPECT_EQ(0, received);
base::RunLoop().RunUntilIdle();
// Read bytes 30-39 from the network.
transaction.request_headers = "Range: bytes = 30-39\r\n" EXTRA_HEADER;
transaction.data = "rg: 30-39 ";
RunTransactionAndGetNetworkBytes(&cache, transaction, &sent, &received);
EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes, sent);
EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes, received);
base::RunLoop().RunUntilIdle();
// Read bytes 20-29 and 50-59 from the network, bytes 30-49 from the cache.
transaction.request_headers = "Range: bytes = 20-59\r\n" EXTRA_HEADER;
transaction.data = "rg: 20-29 rg: 30-39 rg: 40-49 rg: 50-59 ";
RunTransactionAndGetNetworkBytes(&cache, transaction, &sent, &received);
EXPECT_EQ(MockNetworkTransaction::kTotalSentBytes * 2, sent);
EXPECT_EQ(MockNetworkTransaction::kTotalReceivedBytes * 2, received);
RemoveMockTransaction(&kRangeGET_TransactionOK);
}
class HttpCachePrefetchValidationTest : public TestWithTaskEnvironment {
protected:
static const int kNumSecondsPerMinute = 60;
static const int kMaxAgeSecs = 100;
static const int kRequireValidationSecs = kMaxAgeSecs + 1;
HttpCachePrefetchValidationTest() : transaction_(kSimpleGET_Transaction) {
DCHECK_LT(kMaxAgeSecs, prefetch_reuse_mins() * kNumSecondsPerMinute);
cache_.http_cache()->SetClockForTesting(&clock_);
cache_.network_layer()->SetClock(&clock_);
transaction_.response_headers = "Cache-Control: max-age=100\n";
}
bool TransactionRequiredNetwork(int load_flags) {
int pre_transaction_count = transaction_count();
transaction_.load_flags = load_flags;
RunTransactionTest(cache_.http_cache(), transaction_);
return pre_transaction_count != transaction_count();
}
void AdvanceTime(int seconds) { clock_.Advance(base::Seconds(seconds)); }
int prefetch_reuse_mins() { return HttpCache::kPrefetchReuseMins; }
// How many times this test has sent requests to the (fake) origin
// server. Every test case needs to make at least one request to initialise
// the cache.
int transaction_count() {
return cache_.network_layer()->transaction_count();
}
MockHttpCache cache_;
ScopedMockTransaction transaction_;
std::string response_headers_;
base::SimpleTestClock clock_;
};
TEST_F(HttpCachePrefetchValidationTest, SkipValidationShortlyAfterPrefetch) {
EXPECT_TRUE(TransactionRequiredNetwork(LOAD_PREFETCH));
AdvanceTime(kRequireValidationSecs);
EXPECT_FALSE(TransactionRequiredNetwork(LOAD_NORMAL));
}
TEST_F(HttpCachePrefetchValidationTest, ValidateLongAfterPrefetch) {
EXPECT_TRUE(TransactionRequiredNetwork(LOAD_PREFETCH));
AdvanceTime(prefetch_reuse_mins() * kNumSecondsPerMinute);
EXPECT_TRUE(TransactionRequiredNetwork(LOAD_NORMAL));
}
TEST_F(HttpCachePrefetchValidationTest, SkipValidationOnceOnly) {
EXPECT_TRUE(TransactionRequiredNetwork(LOAD_PREFETCH));
AdvanceTime(kRequireValidationSecs);
EXPECT_FALSE(TransactionRequiredNetwork(LOAD_NORMAL));
EXPECT_TRUE(TransactionRequiredNetwork(LOAD_NORMAL));
}
TEST_F(HttpCachePrefetchValidationTest, SkipValidationOnceReadOnly) {
EXPECT_TRUE(TransactionRequiredNetwork(LOAD_PREFETCH));
AdvanceTime(kRequireValidationSecs);
EXPECT_FALSE(TransactionRequiredNetwork(LOAD_ONLY_FROM_CACHE |
LOAD_SKIP_CACHE_VALIDATION));
EXPECT_TRUE(TransactionRequiredNetwork(LOAD_NORMAL));
}
TEST_F(HttpCachePrefetchValidationTest, BypassCacheOverwritesPrefetch) {
EXPECT_TRUE(TransactionRequiredNetwork(LOAD_PREFETCH));
AdvanceTime(kRequireValidationSecs);
EXPECT_TRUE(TransactionRequiredNetwork(LOAD_BYPASS_CACHE));
AdvanceTime(kRequireValidationSecs);
EXPECT_TRUE(TransactionRequiredNetwork(LOAD_NORMAL));
}
TEST_F(HttpCachePrefetchValidationTest,
SkipValidationOnExistingEntryThatNeedsValidation) {
EXPECT_TRUE(TransactionRequiredNetwork(LOAD_NORMAL));
AdvanceTime(kRequireValidationSecs);
EXPECT_TRUE(TransactionRequiredNetwork(LOAD_PREFETCH));
AdvanceTime(kRequireValidationSecs);
EXPECT_FALSE(TransactionRequiredNetwork(LOAD_NORMAL));
EXPECT_TRUE(TransactionRequiredNetwork(LOAD_NORMAL));
}
TEST_F(HttpCachePrefetchValidationTest,
SkipValidationOnExistingEntryThatDoesNotNeedValidation) {
EXPECT_TRUE(TransactionRequiredNetwork(LOAD_NORMAL));
EXPECT_FALSE(TransactionRequiredNetwork(LOAD_PREFETCH));
AdvanceTime(kRequireValidationSecs);
EXPECT_FALSE(TransactionRequiredNetwork(LOAD_NORMAL));
EXPECT_TRUE(TransactionRequiredNetwork(LOAD_NORMAL));
}
TEST_F(HttpCachePrefetchValidationTest, PrefetchMultipleTimes) {
EXPECT_TRUE(TransactionRequiredNetwork(LOAD_PREFETCH));
EXPECT_FALSE(TransactionRequiredNetwork(LOAD_PREFETCH));
AdvanceTime(kRequireValidationSecs);
EXPECT_FALSE(TransactionRequiredNetwork(LOAD_NORMAL));
}
TEST_F(HttpCachePrefetchValidationTest, ValidateOnDelayedSecondPrefetch) {
EXPECT_TRUE(TransactionRequiredNetwork(LOAD_PREFETCH));
AdvanceTime(kRequireValidationSecs);
EXPECT_TRUE(TransactionRequiredNetwork(LOAD_PREFETCH));
AdvanceTime(kRequireValidationSecs);
EXPECT_FALSE(TransactionRequiredNetwork(LOAD_NORMAL));
}
TEST_F(HttpCacheTest, StaleContentNotUsedWhenLoadFlagNotSet) {
MockHttpCache cache;
ScopedMockTransaction stale_while_revalidate_transaction(
kSimpleGET_Transaction);
stale_while_revalidate_transaction.response_headers =
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"Age: 10801\n"
"Cache-Control: max-age=0,stale-while-revalidate=86400\n";
// Write to the cache.
RunTransactionTest(cache.http_cache(), stale_while_revalidate_transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
// Send the request again and check that it is sent to the network again.
HttpResponseInfo response_info;
RunTransactionTestWithResponseInfo(
cache.http_cache(), stale_while_revalidate_transaction, &response_info);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_FALSE(response_info.async_revalidation_requested);
}
TEST_F(HttpCacheTest, StaleContentUsedWhenLoadFlagSetAndUsableThenTimesout) {
MockHttpCache cache;
base::SimpleTestClock clock;
cache.http_cache()->SetClockForTesting(&clock);
cache.network_layer()->SetClock(&clock);
clock.Advance(base::Seconds(10));
ScopedMockTransaction stale_while_revalidate_transaction(
kSimpleGET_Transaction);
stale_while_revalidate_transaction.load_flags |=
LOAD_SUPPORT_ASYNC_REVALIDATION;
stale_while_revalidate_transaction.response_headers =
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"Age: 10801\n"
"Cache-Control: max-age=0,stale-while-revalidate=86400\n";
// Write to the cache.
RunTransactionTest(cache.http_cache(), stale_while_revalidate_transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
// Send the request again and check that it is not sent to the network again.
HttpResponseInfo response_info;
RunTransactionTestWithResponseInfo(
cache.http_cache(), stale_while_revalidate_transaction, &response_info);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_TRUE(response_info.async_revalidation_requested);
EXPECT_FALSE(response_info.stale_revalidate_timeout.is_null());
// Move forward in time such that the stale response is no longer valid.
clock.SetNow(response_info.stale_revalidate_timeout);
clock.Advance(base::Seconds(1));
RunTransactionTestWithResponseInfo(
cache.http_cache(), stale_while_revalidate_transaction, &response_info);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_FALSE(response_info.async_revalidation_requested);
}
TEST_F(HttpCacheTest, StaleContentUsedWhenLoadFlagSetAndUsable) {
MockHttpCache cache;
base::SimpleTestClock clock;
cache.http_cache()->SetClockForTesting(&clock);
cache.network_layer()->SetClock(&clock);
clock.Advance(base::Seconds(10));
ScopedMockTransaction stale_while_revalidate_transaction(
kSimpleGET_Transaction);
stale_while_revalidate_transaction.load_flags |=
LOAD_SUPPORT_ASYNC_REVALIDATION;
stale_while_revalidate_transaction.response_headers =
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"Age: 10801\n"
"Cache-Control: max-age=0,stale-while-revalidate=86400\n";
// Write to the cache.
RunTransactionTest(cache.http_cache(), stale_while_revalidate_transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
// Send the request again and check that it is not sent to the network again.
HttpResponseInfo response_info;
RunTransactionTestWithResponseInfo(
cache.http_cache(), stale_while_revalidate_transaction, &response_info);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_TRUE(response_info.async_revalidation_requested);
EXPECT_FALSE(response_info.stale_revalidate_timeout.is_null());
base::Time revalidation_timeout = response_info.stale_revalidate_timeout;
clock.Advance(base::Seconds(1));
EXPECT_TRUE(clock.Now() < revalidation_timeout);
// Fetch the resource again inside the revalidation timeout window.
RunTransactionTestWithResponseInfo(
cache.http_cache(), stale_while_revalidate_transaction, &response_info);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_TRUE(response_info.async_revalidation_requested);
EXPECT_FALSE(response_info.stale_revalidate_timeout.is_null());
// Expect that the original revalidation timeout hasn't changed.
EXPECT_TRUE(revalidation_timeout == response_info.stale_revalidate_timeout);
// mask of async revalidation flag.
stale_while_revalidate_transaction.load_flags &=
~LOAD_SUPPORT_ASYNC_REVALIDATION;
stale_while_revalidate_transaction.status = "HTTP/1.1 304 Not Modified";
// Write 304 to the cache.
RunTransactionTestWithResponseInfo(
cache.http_cache(), stale_while_revalidate_transaction, &response_info);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_FALSE(response_info.async_revalidation_requested);
EXPECT_TRUE(response_info.stale_revalidate_timeout.is_null());
}
TEST_F(HttpCacheTest, StaleContentNotUsedWhenUnusable) {
MockHttpCache cache;
ScopedMockTransaction stale_while_revalidate_transaction(
kSimpleGET_Transaction);
stale_while_revalidate_transaction.load_flags |=
LOAD_SUPPORT_ASYNC_REVALIDATION;
stale_while_revalidate_transaction.response_headers =
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"Age: 10801\n"
"Cache-Control: max-age=0,stale-while-revalidate=1800\n";
// Write to the cache.
RunTransactionTest(cache.http_cache(), stale_while_revalidate_transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
// Send the request again and check that it is sent to the network again.
HttpResponseInfo response_info;
RunTransactionTestWithResponseInfo(
cache.http_cache(), stale_while_revalidate_transaction, &response_info);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_FALSE(response_info.async_revalidation_requested);
}
TEST_F(HttpCacheTest, StaleContentWriteError) {
MockHttpCache cache;
base::SimpleTestClock clock;
cache.http_cache()->SetClockForTesting(&clock);
cache.network_layer()->SetClock(&clock);
clock.Advance(base::Seconds(10));
ScopedMockTransaction stale_while_revalidate_transaction(
kSimpleGET_Transaction);
stale_while_revalidate_transaction.load_flags |=
LOAD_SUPPORT_ASYNC_REVALIDATION;
stale_while_revalidate_transaction.response_headers =
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"Age: 10801\n"
"Cache-Control: max-age=0,stale-while-revalidate=86400\n";
// Write to the cache.
RunTransactionTest(cache.http_cache(), stale_while_revalidate_transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
// Send the request again but inject a write fault. Should still work
// (and not dereference any null pointers).
cache.disk_cache()->set_soft_failures_mask(MockDiskEntry::FAIL_WRITE);
HttpResponseInfo response_info;
RunTransactionTestWithResponseInfo(
cache.http_cache(), stale_while_revalidate_transaction, &response_info);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
}
// Tests that we allow multiple simultaneous, non-overlapping transactions to
// take place on a sparse entry.
TEST_F(HttpCacheTest, RangeGET_MultipleRequests) {
MockHttpCache cache;
// Create a transaction for bytes 0-9.
MockHttpRequest request(kRangeGET_TransactionOK);
MockTransaction transaction(kRangeGET_TransactionOK);
transaction.request_headers = "Range: bytes = 0-9\r\n" EXTRA_HEADER;
transaction.data = "rg: 00-09 ";
AddMockTransaction(&transaction);
TestCompletionCallback callback;
std::unique_ptr<HttpTransaction> trans;
int rv = cache.http_cache()->CreateTransaction(DEFAULT_PRIORITY, &trans);
EXPECT_THAT(rv, IsOk());
ASSERT_TRUE(trans.get());
// Start our transaction.
trans->Start(&request, callback.callback(), NetLogWithSource());
// A second transaction on a different part of the file (the default
// kRangeGET_TransactionOK requests 40-49) should not be blocked by
// the already pending transaction.
RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
// Let the first transaction complete.
callback.WaitForResult();
RemoveMockTransaction(&transaction);
}
// Verify that a range request can be satisfied from a completely cached
// resource with the LOAD_ONLY_FROM_CACHE flag set. Currently it's not
// implemented so it returns ERR_CACHE_MISS. See also
// HttpCacheTest.RangeGET_OK_LoadOnlyFromCache.
// TODO(ricea): Update this test if it is implemented in future.
TEST_F(HttpCacheTest, RangeGET_Previous200_LoadOnlyFromCache) {
MockHttpCache cache;
// Store the whole thing with status 200.
MockTransaction transaction(kETagGET_Transaction);
transaction.url = kRangeGET_TransactionOK.url;
transaction.data = kFullRangeData;
AddMockTransaction(&transaction);
RunTransactionTest(cache.http_cache(), transaction);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
RemoveMockTransaction(&transaction);
AddMockTransaction(&kRangeGET_TransactionOK);
// Now see that we use the stored entry.
MockTransaction transaction2(kRangeGET_TransactionOK);
transaction2.load_flags |= LOAD_ONLY_FROM_CACHE;
MockHttpRequest request(transaction2);
TestCompletionCallback callback;
std::unique_ptr<HttpTransaction> trans;
int rv = cache.http_cache()->CreateTransaction(DEFAULT_PRIORITY, &trans);
EXPECT_THAT(rv, IsOk());
ASSERT_TRUE(trans);
rv = trans->Start(&request, callback.callback(), NetLogWithSource());
if (rv == ERR_IO_PENDING) {
rv = callback.WaitForResult();
}
EXPECT_THAT(rv, IsError(ERR_CACHE_MISS));
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Makes sure that a request stops using the cache when the response headers
// with "Cache-Control: no-store" arrives. That means that another request for
// the same URL can be processed before the response body of the original
// request arrives.
TEST_F(HttpCacheTest, NoStoreResponseShouldNotBlockFollowingRequests) {
MockHttpCache cache;
ScopedMockTransaction mock_transaction(kSimpleGET_Transaction);
mock_transaction.response_headers = "Cache-Control: no-store\n";
MockHttpRequest request(mock_transaction);
auto first = std::make_unique<Context>();
first->result = cache.CreateTransaction(&first->trans);
ASSERT_THAT(first->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, first->trans->GetLoadState());
first->result = first->trans->Start(&request, first->callback.callback(),
NetLogWithSource());
EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE, first->trans->GetLoadState());
base::RunLoop().RunUntilIdle();
EXPECT_EQ(LOAD_STATE_IDLE, first->trans->GetLoadState());
ASSERT_TRUE(first->trans->GetResponseInfo());
EXPECT_TRUE(first->trans->GetResponseInfo()->headers->HasHeaderValue(
"Cache-Control", "no-store"));
// Here we have read the response header but not read the response body yet.
// Let us create the second (read) transaction.
auto second = std::make_unique<Context>();
second->result = cache.CreateTransaction(&second->trans);
ASSERT_THAT(second->result, IsOk());
EXPECT_EQ(LOAD_STATE_IDLE, second->trans->GetLoadState());
second->result = second->trans->Start(&request, second->callback.callback(),
NetLogWithSource());
// Here the second transaction proceeds without reading the first body.
EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE, second->trans->GetLoadState());
base::RunLoop().RunUntilIdle();
EXPECT_EQ(LOAD_STATE_IDLE, second->trans->GetLoadState());
ASSERT_TRUE(second->trans->GetResponseInfo());
EXPECT_TRUE(second->trans->GetResponseInfo()->headers->HasHeaderValue(
"Cache-Control", "no-store"));
ReadAndVerifyTransaction(second->trans.get(), kSimpleGET_Transaction);
}
// Tests that serving a response entirely from cache replays the previous
// SSLInfo.
TEST_F(HttpCacheTest, CachePreservesSSLInfo) {
static const uint16_t kTLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 = 0xc02f;
int status = 0;
SSLConnectionStatusSetCipherSuite(kTLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
&status);
SSLConnectionStatusSetVersion(SSL_CONNECTION_VERSION_TLS1_2, &status);
scoped_refptr<X509Certificate> cert =
ImportCertFromFile(GetTestCertsDirectory(), "ok_cert.pem");
MockHttpCache cache;
ScopedMockTransaction transaction(kSimpleGET_Transaction);
transaction.cert = cert;
transaction.ssl_connection_status = status;
// Fetch the resource.
HttpResponseInfo response_info;
RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
&response_info);
// The request should have hit the network and a cache entry created.
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// The expected SSL state was reported.
EXPECT_EQ(transaction.ssl_connection_status,
response_info.ssl_info.connection_status);
EXPECT_TRUE(cert->EqualsIncludingChain(response_info.ssl_info.cert.get()));
// Fetch the resource again.
RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
&response_info);
// The request should have been reused without hitting the network.
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// The SSL state was preserved.
EXPECT_EQ(status, response_info.ssl_info.connection_status);
EXPECT_TRUE(cert->EqualsIncludingChain(response_info.ssl_info.cert.get()));
}
// Tests that SSLInfo gets updated when revalidating a cached response.
TEST_F(HttpCacheTest, RevalidationUpdatesSSLInfo) {
static const uint16_t kTLS_RSA_WITH_RC4_128_MD5 = 0x0004;
static const uint16_t kTLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 = 0xc02f;
int status1 = 0;
SSLConnectionStatusSetCipherSuite(kTLS_RSA_WITH_RC4_128_MD5, &status1);
SSLConnectionStatusSetVersion(SSL_CONNECTION_VERSION_TLS1, &status1);
int status2 = 0;
SSLConnectionStatusSetCipherSuite(kTLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
&status2);
SSLConnectionStatusSetVersion(SSL_CONNECTION_VERSION_TLS1_2, &status2);
scoped_refptr<X509Certificate> cert1 =
ImportCertFromFile(GetTestCertsDirectory(), "expired_cert.pem");
scoped_refptr<X509Certificate> cert2 =
ImportCertFromFile(GetTestCertsDirectory(), "ok_cert.pem");
MockHttpCache cache;
ScopedMockTransaction transaction(kTypicalGET_Transaction);
transaction.cert = cert1;
transaction.ssl_connection_status = status1;
// Fetch the resource.
HttpResponseInfo response_info;
RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
&response_info);
// The request should have hit the network and a cache entry created.
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
EXPECT_FALSE(response_info.was_cached);
// The expected SSL state was reported.
EXPECT_EQ(status1, response_info.ssl_info.connection_status);
EXPECT_TRUE(cert1->EqualsIncludingChain(response_info.ssl_info.cert.get()));
// The server deploys a more modern configuration but reports 304 on the
// revalidation attempt.
transaction.status = "HTTP/1.1 304 Not Modified";
transaction.cert = cert2;
transaction.ssl_connection_status = status2;
// Fetch the resource again, forcing a revalidation.
transaction.request_headers = "Cache-Control: max-age=0\r\n";
RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
&response_info);
// The request should have been successfully revalidated.
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
EXPECT_TRUE(response_info.was_cached);
// The new SSL state is reported.
EXPECT_EQ(status2, response_info.ssl_info.connection_status);
EXPECT_TRUE(cert2->EqualsIncludingChain(response_info.ssl_info.cert.get()));
}
TEST_F(HttpCacheTest, CacheEntryStatusOther) {
MockHttpCache cache;
HttpResponseInfo response_info;
RunTransactionTestWithResponseInfo(cache.http_cache(), kRangeGET_Transaction,
&response_info);
EXPECT_FALSE(response_info.was_cached);
EXPECT_TRUE(response_info.network_accessed);
EXPECT_EQ(CacheEntryStatus::ENTRY_OTHER, response_info.cache_entry_status);
}
TEST_F(HttpCacheTest, CacheEntryStatusNotInCache) {
MockHttpCache cache;
HttpResponseInfo response_info;
RunTransactionTestWithResponseInfo(cache.http_cache(), kSimpleGET_Transaction,
&response_info);
EXPECT_FALSE(response_info.was_cached);
EXPECT_TRUE(response_info.network_accessed);
EXPECT_EQ(CacheEntryStatus::ENTRY_NOT_IN_CACHE,
response_info.cache_entry_status);
}
TEST_F(HttpCacheTest, CacheEntryStatusUsed) {
MockHttpCache cache;
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
HttpResponseInfo response_info;
RunTransactionTestWithResponseInfo(cache.http_cache(), kSimpleGET_Transaction,
&response_info);
EXPECT_TRUE(response_info.was_cached);
EXPECT_FALSE(response_info.network_accessed);
EXPECT_EQ(CacheEntryStatus::ENTRY_USED, response_info.cache_entry_status);
}
TEST_F(HttpCacheTest, CacheEntryStatusValidated) {
MockHttpCache cache;
RunTransactionTest(cache.http_cache(), kETagGET_Transaction);
ScopedMockTransaction still_valid(kETagGET_Transaction);
still_valid.load_flags = LOAD_VALIDATE_CACHE; // Force a validation.
still_valid.handler = ETagGet_ConditionalRequest_Handler;
HttpResponseInfo response_info;
RunTransactionTestWithResponseInfo(cache.http_cache(), still_valid,
&response_info);
EXPECT_TRUE(response_info.was_cached);
EXPECT_TRUE(response_info.network_accessed);
EXPECT_EQ(CacheEntryStatus::ENTRY_VALIDATED,
response_info.cache_entry_status);
}
TEST_F(HttpCacheTest, CacheEntryStatusUpdated) {
MockHttpCache cache;
RunTransactionTest(cache.http_cache(), kETagGET_Transaction);
ScopedMockTransaction update(kETagGET_Transaction);
update.load_flags = LOAD_VALIDATE_CACHE; // Force a validation.
HttpResponseInfo response_info;
RunTransactionTestWithResponseInfo(cache.http_cache(), update,
&response_info);
EXPECT_FALSE(response_info.was_cached);
EXPECT_TRUE(response_info.network_accessed);
EXPECT_EQ(CacheEntryStatus::ENTRY_UPDATED, response_info.cache_entry_status);
}
TEST_F(HttpCacheTest, CacheEntryStatusCantConditionalize) {
MockHttpCache cache;
cache.FailConditionalizations();
RunTransactionTest(cache.http_cache(), kTypicalGET_Transaction);
HttpResponseInfo response_info;
RunTransactionTestWithResponseInfo(cache.http_cache(),
kTypicalGET_Transaction, &response_info);
EXPECT_FALSE(response_info.was_cached);
EXPECT_TRUE(response_info.network_accessed);
EXPECT_EQ(CacheEntryStatus::ENTRY_CANT_CONDITIONALIZE,
response_info.cache_entry_status);
}
TEST_F(HttpSplitCacheKeyTest, GetResourceURLFromHttpCacheKey) {
base::test::ScopedFeatureList feature_list;
feature_list.InitAndEnableFeature(
net::features::kSplitCacheByNetworkIsolationKey);
MockHttpCache cache;
std::string urls[] = {"http://www.a.com/", "https://b.com/example.html",
"http://example.com/Some Path/Some Leaf?some query"};
for (const std::string& url : urls) {
std::string key = ComputeCacheKey(url);
EXPECT_EQ(GURL(url).spec(), HttpCache::GetResourceURLFromHttpCacheKey(key));
}
}
TEST_F(HttpCacheTest, GetResourceURLFromHttpCacheKey) {
const struct {
std::string input;
std::string output;
} kTestCase[] = {
// Valid input:
{"0/0/https://a.com/", "https://a.com/"},
{"0/0/https://a.com/path", "https://a.com/path"},
{"0/0/https://a.com/?query", "https://a.com/?query"},
{"0/0/https://a.com/#fragment", "https://a.com/#fragment"},
{"0/0/_dk_s_ https://a.com/", "https://a.com/"},
{"0/0/_dk_https://a.com https://b.com https://c.com/", "https://c.com/"},
{"0/0/_dk_shttps://a.com https://b.com https://c.com/", "https://c.com/"},
// Invalid input, producing garbage, without crashing.
{"", ""},
{"0/a.com", "0/a.com"},
{"https://a.com/", "a.com/"},
{"0/https://a.com/", "/a.com/"},
};
for (const auto& test : kTestCase) {
EXPECT_EQ(test.output,
HttpCache::GetResourceURLFromHttpCacheKey(test.input));
}
}
class TestCompletionCallbackForHttpCache : public TestCompletionCallbackBase {
public:
TestCompletionCallbackForHttpCache() = default;
~TestCompletionCallbackForHttpCache() override = default;
CompletionRepeatingCallback callback() {
return base::BindRepeating(&TestCompletionCallbackForHttpCache::SetResult,
base::Unretained(this));
}
const std::vector<int>& results() { return results_; }
private:
std::vector<int> results_;
protected:
void SetResult(int result) override {
results_.push_back(result);
DidSetResult();
}
};
TEST_F(HttpCacheIOCallbackTest, FailedDoomFollowedByOpen) {
MockHttpCache cache;
TestCompletionCallbackForHttpCache cb;
std::unique_ptr<Transaction> transaction =
std::make_unique<Transaction>(DEFAULT_PRIORITY, cache.http_cache());
transaction->SetIOCallBackForTest(cb.callback());
// Create the backend here as our direct calls to DoomEntry and OpenEntry
// below require that it exists.
cache.backend();
// Need a mock transaction in order to use some of MockHttpCache's
// functions.
ScopedMockTransaction m_transaction(kSimpleGET_Transaction);
ActiveEntry* entry1 = nullptr;
cache.disk_cache()->set_force_fail_callback_later(true);
// Queue up our operations.
int rv = DoomEntry(cache.http_cache(), m_transaction.url, transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
cache.disk_cache()->set_force_fail_callback_later(false);
rv = OpenEntry(cache.http_cache(), m_transaction.url, &entry1,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
// Wait for all the results to arrive.
cb.GetResult(rv);
ASSERT_EQ(cb.results().size(), 2u);
// Verify that DoomEntry failed correctly.
ASSERT_EQ(cb.results()[0], ERR_CACHE_DOOM_FAILURE);
// Verify that OpenEntry fails with the same code.
ASSERT_EQ(cb.results()[1], ERR_CACHE_DOOM_FAILURE);
ASSERT_EQ(entry1, nullptr);
}
TEST_F(HttpCacheIOCallbackTest, FailedDoomFollowedByCreate) {
MockHttpCache cache;
TestCompletionCallbackForHttpCache cb;
std::unique_ptr<Transaction> transaction =
std::make_unique<Transaction>(DEFAULT_PRIORITY, cache.http_cache());
transaction->SetIOCallBackForTest(cb.callback());
// Create the backend here as our direct calls to DoomEntry and CreateEntry
// below require that it exists.
cache.backend();
// Need a mock transaction in order to use some of MockHttpCache's
// functions.
ScopedMockTransaction m_transaction(kSimpleGET_Transaction);
ActiveEntry* entry1 = nullptr;
cache.disk_cache()->set_force_fail_callback_later(true);
// Queue up our operations.
int rv = DoomEntry(cache.http_cache(), m_transaction.url, transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
cache.disk_cache()->set_force_fail_callback_later(false);
rv = CreateEntry(cache.http_cache(), m_transaction.url, &entry1,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
// Wait for all the results to arrive.
cb.GetResult(rv);
ASSERT_EQ(cb.results().size(), 2u);
// Verify that DoomEntry failed correctly.
ASSERT_EQ(cb.results()[0], ERR_CACHE_DOOM_FAILURE);
// Verify that CreateEntry requests a restart (CACHE_RACE).
ASSERT_EQ(cb.results()[1], ERR_CACHE_RACE);
ASSERT_EQ(entry1, nullptr);
}
TEST_F(HttpCacheIOCallbackTest, FailedDoomFollowedByDoom) {
MockHttpCache cache;
TestCompletionCallbackForHttpCache cb;
std::unique_ptr<Transaction> transaction =
std::make_unique<Transaction>(DEFAULT_PRIORITY, cache.http_cache());
transaction->SetIOCallBackForTest(cb.callback());
// Create the backend here as our direct calls to DoomEntry below require that
// it exists.
cache.backend();
// Need a mock transaction in order to use some of MockHttpCache's
// functions.
ScopedMockTransaction m_transaction(kSimpleGET_Transaction);
cache.disk_cache()->set_force_fail_callback_later(true);
// Queue up our operations.
int rv = DoomEntry(cache.http_cache(), m_transaction.url, transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
cache.disk_cache()->set_force_fail_callback_later(false);
rv = DoomEntry(cache.http_cache(), m_transaction.url, transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
// Wait for all the results to arrive.
cb.GetResult(rv);
ASSERT_EQ(cb.results().size(), 2u);
// Verify that DoomEntry failed correctly.
ASSERT_EQ(cb.results()[0], ERR_CACHE_DOOM_FAILURE);
// Verify that the second DoomEntry requests a restart (CACHE_RACE).
ASSERT_EQ(cb.results()[1], ERR_CACHE_RACE);
}
TEST_F(HttpCacheIOCallbackTest, FailedOpenFollowedByCreate) {
MockHttpCache cache;
TestCompletionCallbackForHttpCache cb;
std::unique_ptr<Transaction> transaction =
std::make_unique<Transaction>(DEFAULT_PRIORITY, cache.http_cache());
transaction->SetIOCallBackForTest(cb.callback());
// Create the backend here as our direct calls to OpenEntry and CreateEntry
// below require that it exists.
cache.backend();
// Need a mock transaction in order to use some of MockHttpCache's
// functions.
ScopedMockTransaction m_transaction(kSimpleGET_Transaction);
ActiveEntry* entry1 = nullptr;
ActiveEntry* entry2 = nullptr;
cache.disk_cache()->set_force_fail_callback_later(true);
// Queue up our operations.
int rv = OpenEntry(cache.http_cache(), m_transaction.url, &entry1,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
cache.disk_cache()->set_force_fail_callback_later(false);
rv = CreateEntry(cache.http_cache(), m_transaction.url, &entry2,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
// Wait for all the results to arrive.
cb.GetResult(rv);
ASSERT_EQ(cb.results().size(), 2u);
// Verify that OpenEntry failed correctly.
ASSERT_EQ(cb.results()[0], ERR_CACHE_OPEN_FAILURE);
ASSERT_EQ(entry1, nullptr);
// Verify that the CreateEntry requests a restart (CACHE_RACE).
ASSERT_EQ(cb.results()[1], ERR_CACHE_RACE);
ASSERT_EQ(entry2, nullptr);
}
TEST_F(HttpCacheIOCallbackTest, FailedCreateFollowedByOpen) {
MockHttpCache cache;
TestCompletionCallbackForHttpCache cb;
std::unique_ptr<Transaction> transaction =
std::make_unique<Transaction>(DEFAULT_PRIORITY, cache.http_cache());
transaction->SetIOCallBackForTest(cb.callback());
// Create the backend here as our direct calls to CreateEntry and OpenEntry
// below require that it exists.
cache.backend();
// Need a mock transaction in order to use some of MockHttpCache's
// functions.
ScopedMockTransaction m_transaction(kSimpleGET_Transaction);
ActiveEntry* entry1 = nullptr;
ActiveEntry* entry2 = nullptr;
cache.disk_cache()->set_force_fail_callback_later(true);
// Queue up our operations.
int rv = CreateEntry(cache.http_cache(), m_transaction.url, &entry1,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
cache.disk_cache()->set_force_fail_callback_later(false);
rv = OpenEntry(cache.http_cache(), m_transaction.url, &entry2,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
// Wait for all the results to arrive.
cb.GetResult(rv);
ASSERT_EQ(cb.results().size(), 2u);
// Verify that CreateEntry failed correctly.
ASSERT_EQ(cb.results()[0], ERR_CACHE_CREATE_FAILURE);
ASSERT_EQ(entry1, nullptr);
// Verify that the OpenEntry requests a restart (CACHE_RACE).
ASSERT_EQ(cb.results()[1], ERR_CACHE_RACE);
ASSERT_EQ(entry2, nullptr);
}
TEST_F(HttpCacheIOCallbackTest, FailedCreateFollowedByCreate) {
MockHttpCache cache;
TestCompletionCallbackForHttpCache cb;
std::unique_ptr<Transaction> transaction =
std::make_unique<Transaction>(DEFAULT_PRIORITY, cache.http_cache());
transaction->SetIOCallBackForTest(cb.callback());
// Create the backend here as our direct calls to CreateEntry below require
// that it exists.
cache.backend();
// Need a mock transaction in order to use some of MockHttpCache's
// functions.
ScopedMockTransaction m_transaction(kSimpleGET_Transaction);
ActiveEntry* entry1 = nullptr;
ActiveEntry* entry2 = nullptr;
cache.disk_cache()->set_force_fail_callback_later(true);
// Queue up our operations.
int rv = CreateEntry(cache.http_cache(), m_transaction.url, &entry1,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
cache.disk_cache()->set_force_fail_callback_later(false);
rv = CreateEntry(cache.http_cache(), m_transaction.url, &entry2,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
// Wait for all the results to arrive.
cb.GetResult(rv);
ASSERT_EQ(cb.results().size(), 2u);
// Verify the CreateEntry(s) failed.
ASSERT_EQ(cb.results()[0], ERR_CACHE_CREATE_FAILURE);
ASSERT_EQ(entry1, nullptr);
ASSERT_EQ(cb.results()[1], ERR_CACHE_CREATE_FAILURE);
ASSERT_EQ(entry2, nullptr);
}
TEST_F(HttpCacheIOCallbackTest, CreateFollowedByCreate) {
MockHttpCache cache;
TestCompletionCallbackForHttpCache cb;
std::unique_ptr<Transaction> transaction =
std::make_unique<Transaction>(DEFAULT_PRIORITY, cache.http_cache());
transaction->SetIOCallBackForTest(cb.callback());
// Create the backend here as our direct calls to CreateEntry below require
// that it exists.
cache.backend();
// Need a mock transaction in order to use some of MockHttpCache's
// functions.
ScopedMockTransaction m_transaction(kSimpleGET_Transaction);
ActiveEntry* entry1 = nullptr;
ActiveEntry* entry2 = nullptr;
// Queue up our operations.
int rv = CreateEntry(cache.http_cache(), m_transaction.url, &entry1,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
rv = CreateEntry(cache.http_cache(), m_transaction.url, &entry2,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
// Wait for all the results to arrive.
cb.GetResult(rv);
ASSERT_EQ(cb.results().size(), 2u);
// Verify that the first CreateEntry succeeded.
ASSERT_EQ(cb.results()[0], OK);
ASSERT_NE(entry1, nullptr);
// Verify that the second CreateEntry failed.
ASSERT_EQ(cb.results()[1], ERR_CACHE_CREATE_FAILURE);
ASSERT_EQ(entry2, nullptr);
}
TEST_F(HttpCacheIOCallbackTest, OperationFollowedByDoom) {
MockHttpCache cache;
TestCompletionCallbackForHttpCache cb;
std::unique_ptr<Transaction> transaction =
std::make_unique<Transaction>(DEFAULT_PRIORITY, cache.http_cache());
transaction->SetIOCallBackForTest(cb.callback());
// Create the backend here as our direct calls to CreateEntry and DoomEntry
// below require that it exists.
cache.backend();
// Need a mock transaction in order to use some of MockHttpCache's
// functions.
ScopedMockTransaction m_transaction(kSimpleGET_Transaction);
ActiveEntry* entry1 = nullptr;
// Queue up our operations.
// For this test all we need is some operation followed by a doom, a create
// fulfills that requirement.
int rv = CreateEntry(cache.http_cache(), m_transaction.url, &entry1,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
rv = DoomEntry(cache.http_cache(), m_transaction.url, transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
// Wait for all the results to arrive.
cb.GetResult(rv);
ASSERT_EQ(cb.results().size(), 2u);
// Verify that the CreateEntry succeeded.
ASSERT_EQ(cb.results()[0], OK);
// Verify that the DoomEntry requests a restart (CACHE_RACE).
ASSERT_EQ(cb.results()[1], ERR_CACHE_RACE);
}
TEST_F(HttpCacheIOCallbackTest, CreateFollowedByOpenOrCreate) {
MockHttpCache cache;
TestCompletionCallbackForHttpCache cb;
std::unique_ptr<Transaction> transaction =
std::make_unique<Transaction>(DEFAULT_PRIORITY, cache.http_cache());
transaction->SetIOCallBackForTest(cb.callback());
// Create the backend here as our direct calls to CreateEntry and
// OpenOrCreateEntry below require that it exists.
cache.backend();
// Need a mock transaction in order to use some of MockHttpCache's
// functions.
ScopedMockTransaction m_transaction(kSimpleGET_Transaction);
ActiveEntry* entry1 = nullptr;
ActiveEntry* entry2 = nullptr;
// Queue up our operations.
int rv = CreateEntry(cache.http_cache(), m_transaction.url, &entry1,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
rv = OpenOrCreateEntry(cache.http_cache(), m_transaction.url, &entry2,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
// Wait for all the results to arrive.
cb.GetResult(rv);
ASSERT_EQ(cb.results().size(), 2u);
// Verify that the CreateEntry succeeded.
ASSERT_EQ(cb.results()[0], OK);
ASSERT_NE(entry1, nullptr);
// Verify that OpenOrCreateEntry succeeded.
ASSERT_EQ(cb.results()[1], OK);
ASSERT_NE(entry2, nullptr);
ASSERT_EQ(entry1->disk_entry, entry2->disk_entry);
}
TEST_F(HttpCacheIOCallbackTest, FailedCreateFollowedByOpenOrCreate) {
MockHttpCache cache;
TestCompletionCallbackForHttpCache cb;
std::unique_ptr<Transaction> transaction =
std::make_unique<Transaction>(DEFAULT_PRIORITY, cache.http_cache());
transaction->SetIOCallBackForTest(cb.callback());
// Create the backend here as our direct calls to CreateEntry and
// OpenOrCreateEntry below require that it exists.
cache.backend();
// Need a mock transaction in order to use some of MockHttpCache's
// functions.
ScopedMockTransaction m_transaction(kSimpleGET_Transaction);
ActiveEntry* entry1 = nullptr;
ActiveEntry* entry2 = nullptr;
cache.disk_cache()->set_force_fail_callback_later(true);
// Queue up our operations.
int rv = CreateEntry(cache.http_cache(), m_transaction.url, &entry1,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
cache.disk_cache()->set_force_fail_callback_later(false);
rv = OpenOrCreateEntry(cache.http_cache(), m_transaction.url, &entry2,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
// Wait for all the results to arrive.
cb.GetResult(rv);
ASSERT_EQ(cb.results().size(), 2u);
// Verify that CreateEntry failed correctly.
ASSERT_EQ(cb.results()[0], ERR_CACHE_CREATE_FAILURE);
ASSERT_EQ(entry1, nullptr);
// Verify that the OpenOrCreateEntry requests a restart (CACHE_RACE).
ASSERT_EQ(cb.results()[1], ERR_CACHE_RACE);
ASSERT_EQ(entry2, nullptr);
}
TEST_F(HttpCacheIOCallbackTest, OpenFollowedByOpenOrCreate) {
MockHttpCache cache;
TestCompletionCallbackForHttpCache cb;
std::unique_ptr<Transaction> transaction =
std::make_unique<Transaction>(DEFAULT_PRIORITY, cache.http_cache());
transaction->SetIOCallBackForTest(cb.callback());
// Create the backend here as our direct calls to OpenEntry and
// OpenOrCreateEntry below require that it exists.
cache.backend();
// Need a mock transaction in order to use some of MockHttpCache's
// functions.
ScopedMockTransaction m_transaction(kSimpleGET_Transaction);
ActiveEntry* entry0 = nullptr;
ActiveEntry* entry1 = nullptr;
ActiveEntry* entry2 = nullptr;
// First need to create and entry so we can open it.
int rv = CreateEntry(cache.http_cache(), m_transaction.url, &entry0,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
cb.GetResult(rv);
ASSERT_EQ(cb.results().size(), static_cast<size_t>(1));
ASSERT_EQ(cb.results()[0], OK);
ASSERT_NE(entry0, nullptr);
// Manually DeactivateEntry() because OpenEntry() fails if there is an
// existing active entry.
DeactivateEntry(cache.http_cache(), entry0);
// Queue up our operations.
rv = OpenEntry(cache.http_cache(), m_transaction.url, &entry1,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
rv = OpenOrCreateEntry(cache.http_cache(), m_transaction.url, &entry2,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
// Wait for all the results to arrive.
cb.GetResult(rv);
ASSERT_EQ(cb.results().size(), 3u);
// Verify that the OpenEntry succeeded.
ASSERT_EQ(cb.results()[1], OK);
ASSERT_NE(entry1, nullptr);
// Verify that OpenOrCreateEntry succeeded.
ASSERT_EQ(cb.results()[2], OK);
ASSERT_NE(entry2, nullptr);
ASSERT_EQ(entry1->disk_entry, entry2->disk_entry);
}
TEST_F(HttpCacheIOCallbackTest, FailedOpenFollowedByOpenOrCreate) {
MockHttpCache cache;
TestCompletionCallbackForHttpCache cb;
std::unique_ptr<Transaction> transaction =
std::make_unique<Transaction>(DEFAULT_PRIORITY, cache.http_cache());
transaction->SetIOCallBackForTest(cb.callback());
// Create the backend here as our direct calls to OpenEntry and
// OpenOrCreateEntry below require that it exists.
cache.backend();
// Need a mock transaction in order to use some of MockHttpCache's
// functions.
ScopedMockTransaction m_transaction(kSimpleGET_Transaction);
ActiveEntry* entry1 = nullptr;
ActiveEntry* entry2 = nullptr;
cache.disk_cache()->set_force_fail_callback_later(true);
// Queue up our operations.
int rv = OpenEntry(cache.http_cache(), m_transaction.url, &entry1,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
cache.disk_cache()->set_force_fail_callback_later(false);
rv = OpenOrCreateEntry(cache.http_cache(), m_transaction.url, &entry2,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
// Wait for all the results to arrive.
cb.GetResult(rv);
ASSERT_EQ(cb.results().size(), 2u);
// Verify that OpenEntry failed correctly.
ASSERT_EQ(cb.results()[0], ERR_CACHE_OPEN_FAILURE);
ASSERT_EQ(entry1, nullptr);
// Verify that the OpenOrCreateEntry requests a restart (CACHE_RACE).
ASSERT_EQ(cb.results()[1], ERR_CACHE_RACE);
ASSERT_EQ(entry2, nullptr);
}
TEST_F(HttpCacheIOCallbackTest, OpenOrCreateFollowedByCreate) {
MockHttpCache cache;
TestCompletionCallbackForHttpCache cb;
std::unique_ptr<Transaction> transaction =
std::make_unique<Transaction>(DEFAULT_PRIORITY, cache.http_cache());
transaction->SetIOCallBackForTest(cb.callback());
// Create the backend here as our direct calls to OpenOrCreateEntry and
// CreateEntry below require that it exists.
cache.backend();
// Need a mock transaction in order to use some of MockHttpCache's
// functions.
ScopedMockTransaction m_transaction(kSimpleGET_Transaction);
ActiveEntry* entry1 = nullptr;
ActiveEntry* entry2 = nullptr;
// Queue up our operations.
int rv = OpenOrCreateEntry(cache.http_cache(), m_transaction.url, &entry1,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
rv = CreateEntry(cache.http_cache(), m_transaction.url, &entry2,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
// Wait for all the results to arrive.
cb.GetResult(rv);
ASSERT_EQ(cb.results().size(), 2u);
// Verify that the OpenOrCreateEntry succeeded.
ASSERT_EQ(cb.results()[0], OK);
ASSERT_NE(entry1, nullptr);
// Verify that CreateEntry failed.
ASSERT_EQ(cb.results()[1], ERR_CACHE_CREATE_FAILURE);
ASSERT_EQ(entry2, nullptr);
}
TEST_F(HttpCacheIOCallbackTest, OpenOrCreateFollowedByOpenOrCreate) {
MockHttpCache cache;
TestCompletionCallbackForHttpCache cb;
std::unique_ptr<Transaction> transaction =
std::make_unique<Transaction>(DEFAULT_PRIORITY, cache.http_cache());
transaction->SetIOCallBackForTest(cb.callback());
// Create the backend here as our direct calls to OpenOrCreateEntry below
// require that it exists.
cache.backend();
// Need a mock transaction in order to use some of MockHttpCache's
// functions.
ScopedMockTransaction m_transaction(kSimpleGET_Transaction);
ActiveEntry* entry1 = nullptr;
ActiveEntry* entry2 = nullptr;
// Queue up our operations.
int rv = OpenOrCreateEntry(cache.http_cache(), m_transaction.url, &entry1,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
rv = OpenOrCreateEntry(cache.http_cache(), m_transaction.url, &entry2,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
// Wait for all the results to arrive.
cb.GetResult(rv);
ASSERT_EQ(cb.results().size(), 2u);
// Verify that the OpenOrCreateEntry succeeded.
ASSERT_EQ(cb.results()[0], OK);
ASSERT_NE(entry1, nullptr);
// Verify that the other succeeded.
ASSERT_EQ(cb.results()[1], OK);
ASSERT_NE(entry2, nullptr);
}
TEST_F(HttpCacheIOCallbackTest, FailedOpenOrCreateFollowedByOpenOrCreate) {
MockHttpCache cache;
TestCompletionCallbackForHttpCache cb;
std::unique_ptr<Transaction> transaction =
std::make_unique<Transaction>(DEFAULT_PRIORITY, cache.http_cache());
transaction->SetIOCallBackForTest(cb.callback());
// Create the backend here as our direct calls to OpenOrCreateEntry below
// require that it exists.
cache.backend();
// Need a mock transaction in order to use some of MockHttpCache's
// functions.
ScopedMockTransaction m_transaction(kSimpleGET_Transaction);
ActiveEntry* entry1 = nullptr;
ActiveEntry* entry2 = nullptr;
cache.disk_cache()->set_force_fail_callback_later(true);
// Queue up our operations.
int rv = OpenOrCreateEntry(cache.http_cache(), m_transaction.url, &entry1,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
cache.disk_cache()->set_force_fail_callback_later(false);
rv = OpenOrCreateEntry(cache.http_cache(), m_transaction.url, &entry2,
transaction.get());
ASSERT_EQ(rv, ERR_IO_PENDING);
// Wait for all the results to arrive.
cb.GetResult(rv);
ASSERT_EQ(cb.results().size(), 2u);
// Verify that the OpenOrCreateEntry failed.
ASSERT_EQ(cb.results()[0], ERR_CACHE_OPEN_OR_CREATE_FAILURE);
ASSERT_EQ(entry1, nullptr);
// Verify that the other failed.
ASSERT_EQ(cb.results()[1], ERR_CACHE_OPEN_OR_CREATE_FAILURE);
ASSERT_EQ(entry2, nullptr);
}
TEST_F(HttpCacheTest, DnsAliasesNoRevalidation) {
MockHttpCache cache;
HttpResponseInfo response;
ScopedMockTransaction transaction(kSimpleGET_Transaction);
transaction.dns_aliases = {"alias1", "alias2"};
RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
&response);
EXPECT_FALSE(response.was_cached);
EXPECT_THAT(response.dns_aliases, testing::ElementsAre("alias1", "alias2"));
// The second request result in a cache hit and the response used without
// revalidation. Set the transaction alias list to empty to verify that the
// cached aliases are being used.
transaction.dns_aliases = {};
RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
&response);
EXPECT_TRUE(response.was_cached);
EXPECT_THAT(response.dns_aliases, testing::ElementsAre("alias1", "alias2"));
}
TEST_F(HttpCacheTest, NoDnsAliasesNoRevalidation) {
MockHttpCache cache;
HttpResponseInfo response;
ScopedMockTransaction transaction(kSimpleGET_Transaction);
transaction.dns_aliases = {};
RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
&response);
EXPECT_FALSE(response.was_cached);
EXPECT_TRUE(response.dns_aliases.empty());
// The second request should result in a cache hit and the response used
// without revalidation. Set the transaction alias list to nonempty to verify
// that the cached aliases are being used.
transaction.dns_aliases = {"alias"};
RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
&response);
EXPECT_TRUE(response.was_cached);
EXPECT_TRUE(response.dns_aliases.empty());
}
TEST_F(HttpCacheTest, DnsAliasesRevalidation) {
MockHttpCache cache;
HttpResponseInfo response;
ScopedMockTransaction transaction(kTypicalGET_Transaction);
transaction.response_headers =
"Date: Wed, 28 Nov 2007 09:40:09 GMT\n"
"Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
"Cache-Control: max-age=0\n";
transaction.dns_aliases = {"alias1", "alias2"};
RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
&response);
EXPECT_FALSE(response.was_cached);
EXPECT_THAT(response.dns_aliases, testing::ElementsAre("alias1", "alias2"));
// On the second request, the cache should be revalidated. Change the aliases
// to be sure that the new aliases are being used, and have the response be
// cached for next time.
transaction.response_headers = "Cache-Control: max-age=10000\n";
transaction.dns_aliases = {"alias3", "alias4"};
RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
&response);
EXPECT_FALSE(response.was_cached);
EXPECT_THAT(response.dns_aliases, testing::ElementsAre("alias3", "alias4"));
transaction.dns_aliases = {"alias5", "alias6"};
RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
&response);
EXPECT_TRUE(response.was_cached);
EXPECT_THAT(response.dns_aliases, testing::ElementsAre("alias3", "alias4"));
}
TEST_F(HttpCacheTest, FirstPartySetsBypassCache_ShouldBypass_NoId) {
MockHttpCache cache;
HttpResponseInfo response;
ScopedMockTransaction transaction(kSimpleGET_Transaction);
RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
&response);
EXPECT_FALSE(response.was_cached);
transaction.fps_cache_filter = {5};
RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
&response);
EXPECT_FALSE(response.was_cached);
}
TEST_F(HttpCacheTest, FirstPartySetsBypassCache_ShouldBypass_IdTooSmall) {
MockHttpCache cache;
HttpResponseInfo response;
ScopedMockTransaction transaction(kSimpleGET_Transaction);
const int64_t kBrowserRunId = 4;
transaction.browser_run_id = {kBrowserRunId};
RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
&response);
EXPECT_FALSE(response.was_cached);
EXPECT_TRUE(response.browser_run_id.has_value());
EXPECT_EQ(kBrowserRunId, response.browser_run_id.value());
transaction.fps_cache_filter = {5};
RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
&response);
EXPECT_FALSE(response.was_cached);
}
TEST_F(HttpCacheTest, FirstPartySetsBypassCache_ShouldNotBypass) {
MockHttpCache cache;
HttpResponseInfo response;
ScopedMockTransaction transaction(kSimpleGET_Transaction);
const int64_t kBrowserRunId = 5;
transaction.browser_run_id = {kBrowserRunId};
RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
&response);
EXPECT_FALSE(response.was_cached);
EXPECT_TRUE(response.browser_run_id.has_value());
EXPECT_EQ(kBrowserRunId, response.browser_run_id.value());
transaction.fps_cache_filter = {5};
RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
&response);
EXPECT_TRUE(response.was_cached);
}
TEST_F(HttpCacheTest, FirstPartySetsBypassCache_ShouldNotBypass_NoFilter) {
MockHttpCache cache;
HttpResponseInfo response;
ScopedMockTransaction transaction(kSimpleGET_Transaction);
RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
&response);
EXPECT_FALSE(response.was_cached);
RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
&response);
EXPECT_TRUE(response.was_cached);
}
TEST_F(HttpCacheTest, SecurityHeadersAreCopiedToConditionalizedResponse) {
MockHttpCache cache;
HttpResponseInfo response;
ScopedMockTransaction transaction(kSimpleGET_Transaction);
static const Response kNetResponse1 = {
"HTTP/1.1 200 OK",
"Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
"Server: server1\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n"
"Cross-Origin-Resource-Policy: cross-origin\n",
"body1"};
static const Response kNetResponse2 = {
"HTTP/1.1 304 Not Modified",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
"Server: server2\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
""};
kNetResponse1.AssignTo(&transaction);
RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
&response);
// On the second request, the cache is revalidated.
const char kExtraRequestHeaders[] =
"If-Modified-Since: Wed, 06 Feb 2008 22:38:21 GMT\r\n";
transaction.request_headers = kExtraRequestHeaders;
kNetResponse2.AssignTo(&transaction);
RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
&response);
// Verify that the CORP header was carried over to the response.
std::string response_corp_header;
response.headers->GetNormalizedHeader("Cross-Origin-Resource-Policy",
&response_corp_header);
EXPECT_EQ(304, response.headers->response_code());
EXPECT_EQ("cross-origin", response_corp_header);
}
class CacheTransparencyHttpCacheTest
: public HttpCacheTest_SplitCacheFeatureEnabled {
public:
CacheTransparencyHttpCacheTest() {
// The single-keyed cache feature is meaningless when the split cache is not
// enabled. The //net layer doesn't care whether or not the
// "CacheTransparency" feature is enabled.
CHECK(base::FeatureList::IsEnabled(
net::features::kSplitCacheByNetworkIsolationKey));
}
void RunTransactionTestForSingleKeyedCache(
HttpCache* cache,
const MockTransaction& trans_info,
const NetworkIsolationKey& network_isolation_key,
const std::string& checksum) {
ScopedMockTransaction transaction(trans_info);
MockHttpRequest request(transaction);
request.network_isolation_key = network_isolation_key;
request.network_anonymization_key =
net::NetworkAnonymizationKey::CreateFromNetworkIsolationKey(
network_isolation_key);
request.checksum = checksum;
HttpResponseInfo response_info;
RunTransactionTestWithRequest(cache, transaction, request, &response_info);
}
void RunSimpleTransactionTestForSingleKeyedCache(
HttpCache* cache,
const NetworkIsolationKey& network_isolation_key,
const std::string& checksum) {
RunTransactionTestForSingleKeyedCache(cache, kSimpleGET_Transaction,
network_isolation_key, checksum);
}
};
INSTANTIATE_TEST_SUITE_P(
All,
CacheTransparencyHttpCacheTest,
testing::ValuesIn({SplitCacheTestCase::kSplitCacheNikFrameSiteEnabled,
SplitCacheTestCase::kSplitCacheNikCrossSiteFlagEnabled}),
[](const testing::TestParamInfo<SplitCacheTestCase>& info) {
switch (info.param) {
case (SplitCacheTestCase::kSplitCacheDisabled):
return "NotUsedForThisTestSuite";
case (SplitCacheTestCase::kSplitCacheNikFrameSiteEnabled):
return "SplitCacheNikFrameSiteEnabled";
case (SplitCacheTestCase::kSplitCacheNikCrossSiteFlagEnabled):
return "SplitCacheNikCrossSiteFlagEnabled";
}
});
constexpr char kChecksumForSimpleGET[] =
"80B4C37CEF5CFE69B4A90830282AA2BB772DC4CBC00491A219CE5F2AD75C7B58";
TEST_P(CacheTransparencyHttpCacheTest, SuccessfulGET) {
MockHttpCache cache;
// The first request adds the item to the cache.
{
const auto site_a = SchemefulSite(GURL("https://a.com/"));
RunSimpleTransactionTestForSingleKeyedCache(
cache.http_cache(), NetworkIsolationKey(site_a, site_a),
kChecksumForSimpleGET);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// The second request verifies that the same cache entry is used with a
// different NetworkIsolationKey
{
const auto site_b = SchemefulSite(GURL("https://b.com/"));
RunSimpleTransactionTestForSingleKeyedCache(
cache.http_cache(), NetworkIsolationKey(site_b, site_b),
kChecksumForSimpleGET);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
}
TEST_P(CacheTransparencyHttpCacheTest, GETWithChecksumMismatch) {
MockHttpCache cache;
const auto site_a = SchemefulSite(GURL("https://a.com/"));
// The first request adds the item to the cache.
{
RunSimpleTransactionTestForSingleKeyedCache(
cache.http_cache(), NetworkIsolationKey(site_a, site_a),
"000000000000000000000000000000000000000000000000000000000000000");
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// The second request doesn't use the item that was added to the single-keyed
// cache, but adds it to the split cache instead.
{
RunSimpleTransactionTestForSingleKeyedCache(
cache.http_cache(), NetworkIsolationKey(site_a, site_a),
"000000000000000000000000000000000000000000000000000000000000000");
// Fetches from the network again, this time into the split cache.
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
// The third request uses the split cache.
{
RunSimpleTransactionTestForSingleKeyedCache(
cache.http_cache(), NetworkIsolationKey(site_a, site_a),
"000000000000000000000000000000000000000000000000000000000000000");
// Fetches from the split cache.
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(3, cache.disk_cache()->open_count()); // opens both cache entries
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
}
TEST_P(CacheTransparencyHttpCacheTest, GETWithBadResponseCode) {
MockHttpCache cache;
MockTransaction transaction = kSimpleGET_Transaction;
transaction.status = "HTTP/1.1 404 Not Found";
const auto site_a = SchemefulSite(GURL("https://a.com/"));
// The first request adds the item to the single-keyed cache.
{
RunTransactionTestForSingleKeyedCache(cache.http_cache(), transaction,
NetworkIsolationKey(site_a, site_a),
kChecksumForSimpleGET);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// The second request verifies that the cache entry is not re-used
// but a new one is created in the split cache.
{
RunTransactionTestForSingleKeyedCache(cache.http_cache(), transaction,
NetworkIsolationKey(site_a, site_a),
kChecksumForSimpleGET);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
}
// This is identical to GETWithBadResponseCode but with a different response
// code. It's not very realistic as it doesn't call DoneReading(), but it covers
// the relevant code path.
TEST_P(CacheTransparencyHttpCacheTest, RedirectUnusable) {
MockHttpCache cache;
MockTransaction transaction = kSimpleGET_Transaction;
transaction.status = "HTTP/1.1 301 Moved Permanently";
const auto site_a = SchemefulSite(GURL("https://a.com/"));
// The first request adds the item to the single-keyed cache.
{
RunTransactionTestForSingleKeyedCache(cache.http_cache(), transaction,
NetworkIsolationKey(site_a, site_a),
kChecksumForSimpleGET);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// The second request verifies that the cache entry is not re-used
// but a new one is created in the split cache.
{
RunTransactionTestForSingleKeyedCache(cache.http_cache(), transaction,
NetworkIsolationKey(site_a, site_a),
kChecksumForSimpleGET);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
}
TEST_P(CacheTransparencyHttpCacheTest, GETWith206ResponseCode) {
MockHttpCache cache;
MockTransaction transaction = kSimpleGET_Transaction;
// We should never get a partial response since we never send a range request,
// but it behaves differently from other bad response codes.
transaction.status = "HTTP/1.1 206 Partial";
const auto site_a = SchemefulSite(GURL("https://a.com/"));
// The response is not cached.
{
RunTransactionTestForSingleKeyedCache(cache.http_cache(), transaction,
NetworkIsolationKey(site_a, site_a),
kChecksumForSimpleGET);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// It is fetched from the network again.
{
RunTransactionTestForSingleKeyedCache(cache.http_cache(), transaction,
NetworkIsolationKey(site_a, site_a),
kChecksumForSimpleGET);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
}
TEST_P(CacheTransparencyHttpCacheTest, SuccessfulRevalidation) {
MockHttpCache cache;
MockTransaction transaction = kSimpleGET_Transaction;
// Add a cache control header to permit the entry to be cached, with max-age 0
// to force relatidation next time. Add Etag to permit it to be revalidated.
transaction.response_headers =
"Etag: \"foo\"\n"
"Cache-Control: max-age=0\n";
{
const auto site_a = SchemefulSite(GURL("https://a.com/"));
RunTransactionTestForSingleKeyedCache(cache.http_cache(), transaction,
NetworkIsolationKey(site_a, site_a),
kChecksumForSimpleGET);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// The second request revalidates the existing entry.
{
const auto site_b = SchemefulSite(GURL("https://b.com/"));
transaction.status = "HTTP/1.1 304 Not Modified";
// Allow it to be reused without validation next time by increasing max-age.
transaction.response_headers =
"Etag: \"foo\"\n"
"Cache-Control: max-age=10000\n";
RunTransactionTestForSingleKeyedCache(cache.http_cache(), transaction,
NetworkIsolationKey(site_b, site_b),
kChecksumForSimpleGET);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// The third request re-uses the entry.
{
const auto site_c = SchemefulSite(GURL("https://c.com/"));
// Load from cache again.
RunTransactionTestForSingleKeyedCache(cache.http_cache(), transaction,
NetworkIsolationKey(site_c, site_c),
kChecksumForSimpleGET);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
}
TEST_P(CacheTransparencyHttpCacheTest, RevalidationChangingUncheckedHeader) {
MockHttpCache cache;
MockTransaction transaction = kSimpleGET_Transaction;
// Add a cache control header to permit the entry to be cached, with max-age 0
// to force relatidation next time. Add Etag to permit it to be revalidated.
transaction.response_headers =
"Etag: \"foo\"\n"
"Cache-Control: max-age=0\n";
{
const auto site_a = SchemefulSite(GURL("https://a.com/"));
RunTransactionTestForSingleKeyedCache(cache.http_cache(), transaction,
NetworkIsolationKey(site_a, site_a),
kChecksumForSimpleGET);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// The second request revalidates the existing entry.
{
const auto site_b = SchemefulSite(GURL("https://b.com/"));
transaction.status = "HTTP/1.1 304 Not Modified";
// Add a response header. This is the only difference from the
// SuccessfulRevalidation test.
transaction.response_headers =
"Etag: \"foo\"\n"
"Cache-Control: max-age=10000\n"
"X-Unchecked-Header: 1\n";
RunTransactionTestForSingleKeyedCache(cache.http_cache(), transaction,
NetworkIsolationKey(site_b, site_b),
kChecksumForSimpleGET);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// The third request re-uses the entry.
{
const auto site_c = SchemefulSite(GURL("https://c.com/"));
// Load from cache again.
RunTransactionTestForSingleKeyedCache(cache.http_cache(), transaction,
NetworkIsolationKey(site_c, site_c),
kChecksumForSimpleGET);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
}
TEST_P(CacheTransparencyHttpCacheTest, RevalidationChangingCheckedHeader) {
MockHttpCache cache;
MockTransaction transaction = kSimpleGET_Transaction;
// Add a cache control header to permit the entry to be cached, with max-age 0
// to force relatidation next time. Add Etag to permit it to be revalidated.
transaction.response_headers =
"Etag: \"foo\"\n"
"Cache-Control: max-age=0\n";
{
const auto site_a = SchemefulSite(GURL("https://a.com/"));
RunTransactionTestForSingleKeyedCache(cache.http_cache(), transaction,
NetworkIsolationKey(site_a, site_a),
kChecksumForSimpleGET);
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// The second request marks the single-keyed cache entry unusable because the
// checksum no longer matches.
{
const auto site_b = SchemefulSite(GURL("https://b.com/"));
transaction.status = "HTTP/1.1 304 Not Modified";
// Add the "Vary" response header.
transaction.response_headers =
"Etag: \"foo\"\n"
"Cache-Control: max-age=10000\n"
"Vary: Cookie\n";
RunTransactionTestForSingleKeyedCache(cache.http_cache(), transaction,
NetworkIsolationKey(site_b, site_b),
kChecksumForSimpleGET);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_EQ(1, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// The third request has to go to the network because the single-keyed cache
// entry is unusable. It writes a new entry to the split cache.
{
const auto site_c = SchemefulSite(GURL("https://c.com/"));
RunTransactionTestForSingleKeyedCache(cache.http_cache(), transaction,
NetworkIsolationKey(site_c, site_c),
kChecksumForSimpleGET);
EXPECT_EQ(3, cache.network_layer()->transaction_count());
EXPECT_EQ(2, cache.disk_cache()->open_count());
EXPECT_EQ(2, cache.disk_cache()->create_count());
}
}
TEST_P(CacheTransparencyHttpCacheTest, SuccessfulGETManyWriters) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
request.checksum = kChecksumForSimpleGET;
constexpr int kNumTransactions = 2;
std::vector<Context> context_list(kNumTransactions);
for (Context& c : context_list) {
c.result = cache.CreateTransaction(&c.trans);
ASSERT_THAT(c.result, IsOk());
c.result =
c.trans->Start(&request, c.callback.callback(), NetLogWithSource());
}
// Allow all requests to move from the Create queue to the active entry.
// All would have been added to writers.
base::RunLoop().RunUntilIdle();
std::string cache_key = cache.http_cache()
->GenerateCacheKeyForRequest(
&request, /*use_single_keyed_cache=*/true)
.value();
EXPECT_EQ(kNumTransactions, cache.GetCountWriterTransactions(cache_key));
// The second transaction skipped validation, thus only one network
// transaction is created.
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Complete the transactions.
for (Context& c : context_list) {
ReadAndVerifyTransaction(c.trans.get(), kSimpleGET_Transaction);
}
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
TEST_P(CacheTransparencyHttpCacheTest, BadChecksumManyWriters) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
request.checksum =
"0000000000000000000000000000000000000000000000000000000000000000";
constexpr int kNumTransactions = 2;
std::vector<Context> context_list(kNumTransactions);
for (Context& c : context_list) {
c.result = cache.CreateTransaction(&c.trans);
ASSERT_THAT(c.result, IsOk());
c.result =
c.trans->Start(&request, c.callback.callback(), NetLogWithSource());
}
// Allow all requests to move from the Create queue to the active entry.
// All would have been added to writers.
base::RunLoop().RunUntilIdle();
std::string cache_key = cache.http_cache()
->GenerateCacheKeyForRequest(
&request, /*use_single_keyed_cache=*/true)
.value();
EXPECT_EQ(kNumTransactions, cache.GetCountWriterTransactions(cache_key));
// The second transaction skipped validation, thus only one network
// transaction is created.
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
// Complete the transactions.
for (Context& c : context_list) {
ReadAndVerifyTransaction(c.trans.get(), kSimpleGET_Transaction);
}
EXPECT_EQ(1, cache.network_layer()->transaction_count());
EXPECT_EQ(0, cache.disk_cache()->open_count());
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
} // namespace net