blob: 2b16cb77cf667f17015b7ff9ae7234e77c2215ea [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/http/http_cache.h"
#include <stdint.h>
#include <algorithm>
#include <memory>
#include <utility>
#include <vector>
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/macros.h"
#include "base/memory/ptr_util.h"
#include "base/message_loop/message_loop.h"
#include "base/run_loop.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/test/simple_test_clock.h"
#include "net/base/cache_type.h"
#include "net/base/elements_upload_data_stream.h"
#include "net/base/host_port_pair.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/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/test_net_log.h"
#include "net/log/test_net_log_entry.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/test_data_directory.h"
#include "net/websockets/websocket_handshake_stream_base.h"
#include "testing/gtest/include/gtest/gtest.h"
using base::Time;
namespace net {
namespace {
// 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(NetLog::Source::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(NetLog::Source::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());
}
class DeleteCacheCompletionCallback : public TestCompletionCallbackBase {
public:
explicit DeleteCacheCompletionCallback(MockHttpCache* cache)
: cache_(cache),
callback_(base::Bind(&DeleteCacheCompletionCallback::OnComplete,
base::Unretained(this))) {
}
const CompletionCallback& callback() const { return callback_; }
private:
void OnComplete(int result) {
delete cache_;
SetResult(result);
}
MockHttpCache* cache_;
CompletionCallback callback_;
DISALLOW_COPY_AND_ASSIGN(DeleteCacheCompletionCallback);
};
//-----------------------------------------------------------------------------
// helpers
void ReadAndVerifyTransaction(HttpTransaction* trans,
const MockTransaction& trans_info) {
std::string content;
int rv = ReadTransaction(trans, &content);
EXPECT_EQ(OK, rv);
std::string expected(trans_info.data);
EXPECT_EQ(expected, content);
}
void RunTransactionTestBase(HttpCache* cache,
const MockTransaction& trans_info,
const MockHttpRequest& request,
HttpResponseInfo* response_info,
const BoundNetLog& 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_EQ(OK, rv);
ASSERT_TRUE(trans.get());
rv = trans->Start(&request, callback.callback(), net_log);
if (rv == ERR_IO_PENDING)
rv = callback.WaitForResult();
ASSERT_EQ(trans_info.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,
BoundNetLog(), nullptr, nullptr, nullptr, nullptr);
}
void RunTransactionTestAndGetTiming(HttpCache* cache,
const MockTransaction& trans_info,
const BoundNetLog& 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 BoundNetLog& 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, BoundNetLog(), nullptr);
}
void RunTransactionTestWithLog(HttpCache* cache,
const MockTransaction& trans_info,
const BoundNetLog& 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 BoundNetLog& 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->GetNormalizedHeaders(response_headers);
}
void RunTransactionTestWithResponseAndGetTiming(
HttpCache* cache,
const MockTransaction& trans_info,
std::string* response_headers,
const BoundNetLog& log,
LoadTimingInfo* load_timing_info) {
HttpResponseInfo response;
RunTransactionTestBase(cache, trans_info, MockHttpRequest(trans_info),
&response, log, load_timing_info, nullptr, nullptr,
nullptr);
response.headers->GetNormalizedHeaders(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() {}
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;
DISALLOW_COPY_AND_ASSIGN(FastTransactionServer);
};
bool FastTransactionServer::no_store;
const MockTransaction kFastNoStoreGET_Transaction = {
"http://www.google.com/nostore",
"GET",
base::Time(),
"",
LOAD_VALIDATE_CACHE,
"HTTP/1.1 200 OK",
"Cache-Control: max-age=10000\n",
base::Time(),
"<html><body>Google Blah Blah</body></html>",
TEST_MODE_SYNC_NET_START,
&FastTransactionServer::FastNoStoreHandler,
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;
}
~RangeTransactionServer() {
not_modified_ = false;
modified_ = false;
bad_200_ = false;
}
// 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; }
// 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_;
DISALLOW_COPY_AND_ASSIGN(RangeTransactionServer);
};
bool RangeTransactionServer::not_modified_ = false;
bool RangeTransactionServer::modified_ = false;
bool RangeTransactionServer::bad_200_ = false;
// 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 (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) {
// This is not a byte range request. 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() > 79) {
response_status->assign("HTTP/1.1 416 Requested Range Not Satisfiable");
response_data->clear();
return;
}
EXPECT_TRUE(byte_range.ComputeBounds(80));
int start = static_cast<int>(byte_range.first_byte_position());
int end = static_cast<int>(byte_range.last_byte_position());
EXPECT_LT(end, 80);
std::string content_range = base::StringPrintf(
"Content-Range: bytes %d-%d/80\n", start, end);
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 (int block_start = start; block_start < end; block_start += 10) {
base::StringAppendF(&data, "rg: %02d-%02d ",
block_start, block_start + 9);
}
}
*response_data = data;
if (end - start != 9) {
// We also have to fix content-length.
int len = end - start + 1;
std::string content_length = base::StringPrintf("Content-Length: %d\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,
"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 ",
TEST_MODE_NORMAL,
&RangeTransactionServer::RangeHandler,
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) {
std::string raw_headers(
HttpUtil::AssembleRawHeaders(response.data(), response.size()));
scoped_refptr<HttpResponseHeaders> headers(
new HttpResponseHeaders(raw_headers));
ASSERT_EQ(206, headers->response_code());
int64_t range_start, range_end, object_size;
ASSERT_TRUE(
headers->GetContentRange(&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;
ASSERT_TRUE(cache->CreateBackendEntry(kRangeGET_TransactionOK.url, &entry,
NULL));
raw_headers =
HttpUtil::AssembleRawHeaders(raw_headers.data(), raw_headers.size());
HttpResponseInfo response;
response.response_time = base::Time::Now();
response.request_time = base::Time::Now();
response.headers = new HttpResponseHeaders(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(new 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() : result(ERR_IO_PENDING) {}
int result;
TestCompletionCallback callback;
std::unique_ptr<HttpTransaction> trans;
};
class FakeWebSocketHandshakeStreamCreateHelper
: public WebSocketHandshakeStreamBase::CreateHelper {
public:
~FakeWebSocketHandshakeStreamCreateHelper() override {}
WebSocketHandshakeStreamBase* CreateBasicStream(
std::unique_ptr<ClientSocketHandle> connect,
bool using_proxy) override {
return NULL;
}
WebSocketHandshakeStreamBase* CreateSpdyStream(
const base::WeakPtr<SpdySession>& session,
bool use_relative_url) override {
return NULL;
}
};
// Returns true if |entry| is not one of the log types paid attention to in this
// test. Note that TYPE_HTTP_CACHE_WRITE_INFO and TYPE_HTTP_CACHE_*_DATA are
// ignored.
bool ShouldIgnoreLogEntry(const TestNetLogEntry& entry) {
switch (entry.type) {
case NetLog::TYPE_HTTP_CACHE_GET_BACKEND:
case NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY:
case NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY:
case NetLog::TYPE_HTTP_CACHE_ADD_TO_ENTRY:
case NetLog::TYPE_HTTP_CACHE_DOOM_ENTRY:
case NetLog::TYPE_HTTP_CACHE_READ_INFO:
return false;
default:
return true;
}
}
// Modifies |entries| to only include log entries created by the cache layer and
// asserted on in these tests.
void FilterLogEntries(TestNetLogEntry::List* entries) {
entries->erase(std::remove_if(entries->begin(), entries->end(),
&ShouldIgnoreLogEntry),
entries->end());
}
bool LogContainsEventType(const BoundTestNetLog& log,
NetLog::EventType expected) {
TestNetLogEntry::List entries;
log.GetEntries(&entries);
for (size_t i = 0; i < entries.size(); i++) {
if (entries[i].type == expected)
return true;
}
return false;
}
} // namespace
//-----------------------------------------------------------------------------
// Tests.
TEST(HttpCache, CreateThenDestroy) {
MockHttpCache cache;
std::unique_ptr<HttpTransaction> trans;
EXPECT_EQ(OK, cache.CreateTransaction(&trans));
ASSERT_TRUE(trans.get());
}
TEST(HttpCache, 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_EQ(OK, cb.GetResult(rv));
}
TEST(HttpCache, SimpleGET) {
MockHttpCache cache;
BoundTestNetLog log;
LoadTimingInfo load_timing_info;
// Write to the cache.
RunTransactionTestAndGetTiming(cache.http_cache(), kSimpleGET_Transaction,
log.bound(), &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);
}
TEST(HttpCache, SimpleGETNoDiskCache) {
MockHttpCache cache;
cache.disk_cache()->set_fail_requests();
BoundTestNetLog log;
LoadTimingInfo load_timing_info;
// Read from the network, and don't use the cache.
RunTransactionTestAndGetTiming(cache.http_cache(), kSimpleGET_Transaction,
log.bound(), &load_timing_info);
// Check that the NetLog was filled as expected.
// (We attempted to both Open and Create entries, but both failed).
TestNetLogEntry::List entries;
log.GetEntries(&entries);
FilterLogEntries(&entries);
EXPECT_EQ(6u, entries.size());
EXPECT_TRUE(
LogContainsBeginEvent(entries, 0, NetLog::TYPE_HTTP_CACHE_GET_BACKEND));
EXPECT_TRUE(
LogContainsEndEvent(entries, 1, NetLog::TYPE_HTTP_CACHE_GET_BACKEND));
EXPECT_TRUE(
LogContainsBeginEvent(entries, 2, NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
EXPECT_TRUE(
LogContainsEndEvent(entries, 3, NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
EXPECT_TRUE(
LogContainsBeginEvent(entries, 4, NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY));
EXPECT_TRUE(
LogContainsEndEvent(entries, 5, NetLog::TYPE_HTTP_CACHE_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(HttpCache, SimpleGETNoDiskCache2) {
// This will initialize a cache object with NULL backend.
std::unique_ptr<MockBlockingBackendFactory> factory(
new 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(HttpCache, ReleaseBuffer) {
MockHttpCache cache;
// Write to the cache.
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
MockHttpRequest request(kSimpleGET_Transaction);
std::unique_ptr<HttpTransaction> trans;
ASSERT_EQ(OK, cache.CreateTransaction(&trans));
const int kBufferSize = 10;
scoped_refptr<IOBuffer> buffer(new IOBuffer(kBufferSize));
ReleaseBufferCompletionCallback cb(buffer.get());
int rv = trans->Start(&request, cb.callback(), BoundNetLog());
EXPECT_EQ(OK, cb.GetResult(rv));
rv = trans->Read(buffer.get(), kBufferSize, cb.callback());
EXPECT_EQ(kBufferSize, cb.GetResult(rv));
}
TEST(HttpCache, SimpleGETWithDiskFailures) {
MockHttpCache cache;
cache.disk_cache()->set_soft_failures(true);
// 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(HttpCache, SimpleGETWithDiskFailures2) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
std::unique_ptr<Context> c(new Context());
int rv = cache.CreateTransaction(&c->trans);
ASSERT_EQ(OK, rv);
rv = c->trans->Start(&request, c->callback.callback(), BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
rv = c->callback.WaitForResult();
// Start failing request now.
cache.disk_cache()->set_soft_failures(true);
// We have to open the entry again to propagate the failure flag.
disk_cache::Entry* en;
ASSERT_TRUE(cache.OpenBackendEntry(kSimpleGET_Transaction.url, &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(HttpCache, 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(true);
// Now fail to read from the cache.
std::unique_ptr<Context> c(new Context());
int rv = cache.CreateTransaction(&c->trans);
ASSERT_EQ(OK, rv);
MockHttpRequest request(kSimpleGET_Transaction);
rv = c->trans->Start(&request, c->callback.callback(), BoundNetLog());
EXPECT_EQ(OK, c->callback.GetResult(rv));
// Now verify that the entry was removed from the cache.
cache.disk_cache()->set_soft_failures(false);
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(HttpCache, SimpleGET_LoadOnlyFromCache_Hit) {
MockHttpCache cache;
BoundTestNetLog log;
LoadTimingInfo load_timing_info;
// Write to the cache.
RunTransactionTestAndGetTiming(cache.http_cache(), kSimpleGET_Transaction,
log.bound(), &load_timing_info);
// Check that the NetLog was filled as expected.
TestNetLogEntry::List entries;
log.GetEntries(&entries);
FilterLogEntries(&entries);
EXPECT_EQ(8u, entries.size());
EXPECT_TRUE(
LogContainsBeginEvent(entries, 0, NetLog::TYPE_HTTP_CACHE_GET_BACKEND));
EXPECT_TRUE(
LogContainsEndEvent(entries, 1, NetLog::TYPE_HTTP_CACHE_GET_BACKEND));
EXPECT_TRUE(
LogContainsBeginEvent(entries, 2, NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
EXPECT_TRUE(
LogContainsEndEvent(entries, 3, NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
EXPECT_TRUE(
LogContainsBeginEvent(entries, 4, NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY));
EXPECT_TRUE(
LogContainsEndEvent(entries, 5, NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY));
EXPECT_TRUE(
LogContainsBeginEvent(entries, 6, NetLog::TYPE_HTTP_CACHE_ADD_TO_ENTRY));
EXPECT_TRUE(
LogContainsEndEvent(entries, 7, NetLog::TYPE_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;
log.Clear();
RunTransactionTestAndGetTiming(cache.http_cache(), transaction, log.bound(),
&load_timing_info);
// Check that the NetLog was filled as expected.
log.GetEntries(&entries);
FilterLogEntries(&entries);
EXPECT_EQ(8u, entries.size());
EXPECT_TRUE(
LogContainsBeginEvent(entries, 0, NetLog::TYPE_HTTP_CACHE_GET_BACKEND));
EXPECT_TRUE(
LogContainsEndEvent(entries, 1, NetLog::TYPE_HTTP_CACHE_GET_BACKEND));
EXPECT_TRUE(
LogContainsBeginEvent(entries, 2, NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
EXPECT_TRUE(
LogContainsEndEvent(entries, 3, NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
EXPECT_TRUE(
LogContainsBeginEvent(entries, 4, NetLog::TYPE_HTTP_CACHE_ADD_TO_ENTRY));
EXPECT_TRUE(
LogContainsEndEvent(entries, 5, NetLog::TYPE_HTTP_CACHE_ADD_TO_ENTRY));
EXPECT_TRUE(
LogContainsBeginEvent(entries, 6, NetLog::TYPE_HTTP_CACHE_READ_INFO));
EXPECT_TRUE(
LogContainsEndEvent(entries, 7, NetLog::TYPE_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(HttpCache, SimpleGET_LoadOnlyFromCache_Miss) {
MockHttpCache cache;
// force this transaction to read from the cache
MockTransaction transaction(kSimpleGET_Transaction);
transaction.load_flags |= LOAD_ONLY_FROM_CACHE;
MockHttpRequest request(transaction);
TestCompletionCallback callback;
std::unique_ptr<HttpTransaction> trans;
ASSERT_EQ(OK, cache.CreateTransaction(&trans));
int rv = trans->Start(&request, callback.callback(), BoundNetLog());
if (rv == ERR_IO_PENDING)
rv = callback.WaitForResult();
ASSERT_EQ(ERR_CACHE_MISS, rv);
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(HttpCache, 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_PREFERRING_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());
}
TEST(HttpCache, SimpleGET_LoadPreferringCache_Miss) {
MockHttpCache cache;
// force this transaction to read from the cache if valid
MockTransaction transaction(kSimpleGET_Transaction);
transaction.load_flags |= LOAD_PREFERRING_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());
}
// Tests LOAD_PREFERRING_CACHE in the presence of vary headers.
TEST(HttpCache, 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_PREFERRING_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());
RemoveMockTransaction(&transaction);
}
// Tests LOAD_PREFERRING_CACHE in the presence of vary headers.
TEST(HttpCache, 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_PREFERRING_CACHE;
transaction.request_headers = "Foo: none\r\n";
BoundTestNetLog log;
LoadTimingInfo load_timing_info;
RunTransactionTestAndGetTiming(cache.http_cache(), transaction, log.bound(),
&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 was_cached was set properly on a failure, even if the cached
// response wasn't returned.
TEST(HttpCache, SimpleGET_CacheSignal_Failure) {
MockHttpCache cache;
// 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());
RemoveMockTransaction(&transaction);
// Network failure with error; should fail but have was_cached set.
transaction.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_EQ(OK, rv);
ASSERT_TRUE(trans.get());
rv = trans->Start(&request, callback.callback(), BoundNetLog());
EXPECT_EQ(ERR_FAILED, callback.GetResult(rv));
const HttpResponseInfo* response_info = trans->GetResponseInfo();
ASSERT_TRUE(response_info);
EXPECT_TRUE(response_info->was_cached);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
RemoveMockTransaction(&transaction);
}
// Confirm if we have an empty cache, a read is marked as network verified.
TEST(HttpCache, 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);
}
// Confirm if we have a fresh entry in cache, it isn't marked as
// network verified.
TEST(HttpCache, 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.server_data_unavailable);
EXPECT_FALSE(response_info.network_accessed);
}
TEST(HttpCache, 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;
BoundTestNetLog log;
LoadTimingInfo load_timing_info;
// Write to the cache.
RunTransactionTestAndGetTiming(cache.http_cache(), transaction, log.bound(),
&load_timing_info);
// Check that the NetLog was filled as expected.
TestNetLogEntry::List entries;
log.GetEntries(&entries);
FilterLogEntries(&entries);
EXPECT_EQ(8u, entries.size());
EXPECT_TRUE(
LogContainsBeginEvent(entries, 0, NetLog::TYPE_HTTP_CACHE_GET_BACKEND));
EXPECT_TRUE(
LogContainsEndEvent(entries, 1, NetLog::TYPE_HTTP_CACHE_GET_BACKEND));
EXPECT_TRUE(
LogContainsBeginEvent(entries, 2, NetLog::TYPE_HTTP_CACHE_DOOM_ENTRY));
EXPECT_TRUE(
LogContainsEndEvent(entries, 3, NetLog::TYPE_HTTP_CACHE_DOOM_ENTRY));
EXPECT_TRUE(
LogContainsBeginEvent(entries, 4, NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY));
EXPECT_TRUE(
LogContainsEndEvent(entries, 5, NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY));
EXPECT_TRUE(
LogContainsBeginEvent(entries, 6, NetLog::TYPE_HTTP_CACHE_ADD_TO_ENTRY));
EXPECT_TRUE(
LogContainsEndEvent(entries, 7, NetLog::TYPE_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(HttpCache, 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(HttpCache, 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(HttpCache, 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;
BoundTestNetLog log;
LoadTimingInfo load_timing_info;
RunTransactionTestWithResponseInfoAndGetTiming(
cache.http_cache(), transaction, &response_info, log.bound(),
&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(HttpCache, 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());
}
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(HttpCache, SimpleGET_PreserveRequestHeaders) {
MockHttpCache cache;
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());
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(HttpCache, ConditionalizedGET_PreserveRequestHeaders) {
MockHttpCache cache;
// 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(HttpCache, SimpleGET_ManyReaders) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
std::vector<Context*> context_list;
const int kNumTransactions = 5;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(new Context());
Context* c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_EQ(OK, c->result);
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
c->result =
c->trans->Start(&request, c->callback.callback(), BoundNetLog());
}
// All requests are waiting for the active entry.
for (int i = 0; i < kNumTransactions; ++i) {
Context* c = context_list[i];
EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE, c->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 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());
// All requests depend on the writer, and the writer is between Start and
// Read, i.e. idle.
for (int i = 0; i < kNumTransactions; ++i) {
Context* c = context_list[i];
EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
}
for (int i = 0; i < kNumTransactions; ++i) {
Context* c = context_list[i];
if (c->result == ERR_IO_PENDING)
c->result = c->callback.WaitForResult();
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());
for (int i = 0; i < kNumTransactions; ++i) {
Context* c = context_list[i];
delete c;
}
}
// 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(HttpCache, SimpleGET_RacingReaders) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
MockHttpRequest reader_request(kSimpleGET_Transaction);
reader_request.load_flags = LOAD_ONLY_FROM_CACHE;
std::vector<Context*> context_list;
const int kNumTransactions = 5;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(new Context());
Context* c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_EQ(OK, c->result);
MockHttpRequest* this_request = &request;
if (i == 1 || i == 2)
this_request = &reader_request;
c->result =
c->trans->Start(this_request, c->callback.callback(), BoundNetLog());
}
// 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];
ASSERT_EQ(ERR_IO_PENDING, c->result);
c->result = c->callback.WaitForResult();
ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
// Now we have 2 active readers and two queued transactions.
EXPECT_EQ(LOAD_STATE_IDLE, context_list[2]->trans->GetLoadState());
EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE,
context_list[3]->trans->GetLoadState());
c = context_list[1];
ASSERT_EQ(ERR_IO_PENDING, c->result);
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];
c->trans.reset();
for (int i = 3; i < kNumTransactions; ++i) {
Context* c = context_list[i];
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());
for (int i = 0; i < kNumTransactions; ++i) {
Context* c = context_list[i];
delete c;
}
}
// 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(HttpCache, 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(base::WrapUnique(new Context()));
Context* c = context_list[i].get();
c->result = cache.CreateTransaction(&c->trans);
ASSERT_EQ(OK, c->result);
MockHttpRequest* this_request = &request;
if (i == 3)
this_request = &writer_request;
c->result =
c->trans->Start(this_request, c->callback.callback(), BoundNetLog());
}
// 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 first queued transaction.
context_list[1].reset();
for (int i = 0; i < kNumTransactions; ++i) {
if (i == 1)
continue;
Context* c = context_list[i].get();
ASSERT_EQ(ERR_IO_PENDING, c->result);
c->result = c->callback.WaitForResult();
ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
}
}
// 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(HttpCache, 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<Context*> context_list;
const int kNumTransactions = 3;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(new Context());
Context* c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_EQ(OK, c->result);
c->result =
c->trans->Start(&request, c->callback.callback(), BoundNetLog());
}
// 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());
// 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];
if (c->result == ERR_IO_PENDING)
c->result = c->callback.WaitForResult();
ReadAndVerifyTransaction(c->trans.get(), kFastNoStoreGET_Transaction);
delete c;
}
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(&kFastNoStoreGET_Transaction);
}
TEST(HttpCache, SimpleGET_ManyWriters_CancelFirst) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
std::vector<Context*> context_list;
const int kNumTransactions = 2;
for (int i = 0; i < kNumTransactions; ++i) {
context_list.push_back(new Context());
Context* c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_EQ(OK, c->result);
c->result =
c->trans->Start(&request, c->callback.callback(), BoundNetLog());
}
// 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());
for (int i = 0; i < kNumTransactions; ++i) {
Context* c = context_list[i];
if (c->result == ERR_IO_PENDING)
c->result = c->callback.WaitForResult();
// Destroy only the first transaction.
if (i == 0) {
delete c;
context_list[i] = NULL;
}
}
// Complete the rest of the transactions.
for (int i = 1; i < kNumTransactions; ++i) {
Context* c = context_list[i];
ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
}
// We should have had to re-open the disk 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 = 1; i < kNumTransactions; ++i) {
Context* c = context_list[i];
delete c;
}
}
// Tests that we can cancel requests that are queued waiting to open the disk
// cache entry.
TEST(HttpCache, SimpleGET_ManyWriters_CancelCreate) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
std::vector<Context*> context_list;
const int kNumTransactions = 5;
for (int i = 0; i < kNumTransactions; i++) {
context_list.push_back(new Context());
Context* c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_EQ(OK, c->result);
c->result =
c->trans->Start(&request, c->callback.callback(), BoundNetLog());
}
// 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.
delete context_list[3];
context_list[3] = NULL;
// Cancel the request that is creating the entry. This will force the pending
// operations to restart.
delete context_list[0];
context_list[0] = NULL;
// Complete the rest of the transactions.
for (int i = 1; i < kNumTransactions; i++) {
Context* c = context_list[i];
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());
for (int i = 1; i < kNumTransactions; ++i) {
delete context_list[i];
}
}
// Tests that we can cancel a single request to open a disk cache entry.
TEST(HttpCache, SimpleGET_CancelCreate) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
Context* c = new Context();
c->result = cache.CreateTransaction(&c->trans);
ASSERT_EQ(OK, c->result);
c->result = c->trans->Start(&request, c->callback.callback(), BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, c->result);
// 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();
delete c;
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1, cache.disk_cache()->create_count());
}
// Tests that we delete/create entries even if multiple requests are queued.
TEST(HttpCache, SimpleGET_ManyWriters_BypassCache) {
MockHttpCache cache;
MockHttpRequest request(kSimpleGET_Transaction);
request.load_flags = LOAD_BYPASS_CACHE;
std::vector<Context*> context_list;
const int kNumTransactions = 5;
for (int i = 0; i < kNumTransactions; i++) {
context_list.push_back(new Context());
Context* c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_EQ(OK, c->result);
c->result =
c->trans->Start(&request, c->callback.callback(), BoundNetLog());
}
// 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];
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());
for (int i = 0; i < kNumTransactions; ++i) {
delete context_list[i];
}
}
// Tests that a (simulated) timeout allows transactions waiting on the cache
// lock to continue.
TEST(HttpCache, SimpleGET_WriterTimeout) {
MockHttpCache cache;
cache.BypassCacheLock();
MockHttpRequest request(kSimpleGET_Transaction);
Context c1, c2;
ASSERT_EQ(OK, cache.CreateTransaction(&c1.trans));
ASSERT_EQ(ERR_IO_PENDING,
c1.trans->Start(&request, c1.callback.callback(), BoundNetLog()));
ASSERT_EQ(OK, cache.CreateTransaction(&c2.trans));
ASSERT_EQ(ERR_IO_PENDING,
c2.trans->Start(&request, c2.callback.callback(), BoundNetLog()));
// 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);
}
TEST(HttpCache, 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_EQ(OK, cache.CreateTransaction(&trans));
int rv = trans->Start(&request, callback.callback(), BoundNetLog());
if (rv == ERR_IO_PENDING)
rv = callback.WaitForResult();
ASSERT_EQ(OK, rv);
scoped_refptr<IOBuffer> buf(new IOBuffer(256));
rv = trans->Read(buf.get(), 256, callback.callback());
EXPECT_EQ(ERR_IO_PENDING, rv);
// 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(HttpCache, SimpleGET_ManyWriters_DeleteCache) {
std::unique_ptr<MockHttpCache> cache(
new MockHttpCache(base::WrapUnique(new MockBackendNoCbFactory())));
MockHttpRequest request(kSimpleGET_Transaction);
std::vector<Context*> context_list;
const int kNumTransactions = 5;
for (int i = 0; i < kNumTransactions; i++) {
context_list.push_back(new Context());
Context* c = context_list[i];
c->result = cache->CreateTransaction(&c->trans);
ASSERT_EQ(OK, c->result);
c->result =
c->trans->Start(&request, c->callback.callback(), BoundNetLog());
}
// 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();
// There is not much to do with the transactions at this point... they are
// waiting for a callback that will not fire.
for (int i = 0; i < kNumTransactions; ++i) {
delete context_list[i];
}
}
// Tests that we queue requests when initializing the backend.
TEST(HttpCache, SimpleGET_WaitForBackend) {
MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
MockHttpCache cache(base::WrapUnique(factory));
MockHttpRequest request0(kSimpleGET_Transaction);
MockHttpRequest request1(kTypicalGET_Transaction);
MockHttpRequest request2(kETagGET_Transaction);
std::vector<Context*> context_list;
const int kNumTransactions = 3;
for (int i = 0; i < kNumTransactions; i++) {
context_list.push_back(new Context());
Context* c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_EQ(OK, c->result);
}
context_list[0]->result = context_list[0]->trans->Start(
&request0, context_list[0]->callback.callback(), BoundNetLog());
context_list[1]->result = context_list[1]->trans->Start(
&request1, context_list[1]->callback.callback(), BoundNetLog());
context_list[2]->result = context_list[2]->trans->Start(
&request2, context_list[2]->callback.callback(), BoundNetLog());
// 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->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());
delete context_list[i];
}
}
// Tests that we can cancel requests that are queued waiting for the backend
// to be initialized.
TEST(HttpCache, SimpleGET_WaitForBackend_CancelCreate) {
MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
MockHttpCache cache(base::WrapUnique(factory));
MockHttpRequest request0(kSimpleGET_Transaction);
MockHttpRequest request1(kTypicalGET_Transaction);
MockHttpRequest request2(kETagGET_Transaction);
std::vector<Context*> context_list;
const int kNumTransactions = 3;
for (int i = 0; i < kNumTransactions; i++) {
context_list.push_back(new Context());
Context* c = context_list[i];
c->result = cache.CreateTransaction(&c->trans);
ASSERT_EQ(OK, c->result);
}
context_list[0]->result = context_list[0]->trans->Start(
&request0, context_list[0]->callback.callback(), BoundNetLog());
context_list[1]->result = context_list[1]->trans->Start(
&request1, context_list[1]->callback.callback(), BoundNetLog());
context_list[2]->result = context_list[2]->trans->Start(
&request2, context_list[2]->callback.callback(), BoundNetLog());
// 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.
delete context_list[1];
context_list[1] = NULL;
// Cancel the request that is creating the entry.
delete context_list[0];
context_list[0] = NULL;
// Complete the last transaction.
factory->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());
delete context_list[2];
}
// Tests that we can delete the cache while creating the backend.
TEST(HttpCache, DeleteCacheWaitingForBackend) {
MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
std::unique_ptr<MockHttpCache> cache(
new MockHttpCache(base::WrapUnique(factory)));
MockHttpRequest request(kSimpleGET_Transaction);
std::unique_ptr<Context> c(new Context());
c->result = cache->CreateTransaction(&c->trans);
ASSERT_EQ(OK, c->result);
c->trans->Start(&request, c->callback.callback(), BoundNetLog());
// 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());
// We cannot call FinishCreation because the factory itself will go away with
// the cache, so grab the callback and attempt to use it.
CompletionCallback callback = factory->callback();
std::unique_ptr<disk_cache::Backend>* backend = factory->backend();
cache.reset();
base::RunLoop().RunUntilIdle();
backend->reset();
callback.Run(ERR_ABORTED);
}
// Tests that we can delete the cache while creating the backend, from within
// one of the callbacks.
TEST(HttpCache, DeleteCacheWaitingForBackend2) {
MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
MockHttpCache* cache = new MockHttpCache(base::WrapUnique(factory));
DeleteCacheCompletionCallback cb(cache);
disk_cache::Backend* backend;
int rv = cache->http_cache()->GetBackend(&backend, cb.callback());
EXPECT_EQ(ERR_IO_PENDING, rv);
// Now let's queue a regular transaction
MockHttpRequest request(kSimpleGET_Transaction);
std::unique_ptr<Context> c(new Context());
c->result = cache->CreateTransaction(&c->trans);
ASSERT_EQ(OK, c->result);
c->trans->Start(&request, c->callback.callback(), BoundNetLog());
// And another direct backend request.
TestCompletionCallback cb2;
rv = cache->http_cache()->GetBackend(&backend, cb2.callback());
EXPECT_EQ(ERR_IO_PENDING, rv);
// 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->FinishCreation();
rv = cb.WaitForResult();
// The cache should be gone by now.
base::RunLoop().RunUntilIdle();
EXPECT_EQ(OK, c->callback.GetResult(c->result));
EXPECT_FALSE(cb2.have_result());
}
// Fails only on bots. crbug.com/533640
#if defined(OS_ANDROID)
#define MAYBE_TypicalGET_ConditionalRequest \
DISABLED_TypicalGET_ConditionalRequest
#else
#define MAYBE_TypicalGET_ConditionalRequest TypicalGET_ConditionalRequest
#endif
TEST(HttpCache, MAYBE_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.
BoundTestNetLog log;
LoadTimingInfo load_timing_info;
RunTransactionTestAndGetTiming(cache.http_cache(), kTypicalGET_Transaction,
log.bound(), &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(HttpCache, 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;
BoundTestNetLog log;
LoadTimingInfo load_timing_info;
IPEndPoint remote_endpoint;
RunTransactionTestAndGetTimingAndConnectedSocketAddress(
cache.http_cache(), transaction, log.bound(), &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(HttpCache, 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;
BoundTestNetLog log;
LoadTimingInfo load_timing_info;
RunTransactionTestAndGetTiming(cache.http_cache(), transaction, log.bound(),
&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(HttpCache, 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";
BoundTestNetLog log;
LoadTimingInfo load_timing_info;
RunTransactionTestAndGetTiming(cache.http_cache(), transaction, log.bound(),
&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(HttpCache, 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";
BoundTestNetLog log;
LoadTimingInfo load_timing_info;
RunTransactionTestAndGetTiming(cache.http_cache(), transaction, log.bound(),
&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(HttpCache, 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(HttpCache, 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(HttpCache, 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(HttpCache, 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(HttpCache, 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(HttpCache, 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(HttpCache, 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.
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 = { 0 };
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 = { 0 };
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;
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;
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(HttpCache, 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(HttpCache, 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(HttpCache, 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(HttpCache, 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 = { 0 };
mock_network_response.url = kUrl;
AddMockTransaction(&mock_network_response);
MockTransaction request = { 0 };
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(HttpCache, 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 = { 0 };
mock_network_response.url = kUrl;
AddMockTransaction(&mock_network_response);
MockTransaction request = { 0 };
request.url = kUrl;
request.method = "GET";
request.request_headers = kExtraRequestHeaders;
kNetResponse.AssignTo(&mock_network_response); // Network mock.
kNetResponse.AssignTo(&request); // Expected result.