Google Git
Sign in
chromium / chromium / src.git / 39.0.2171.95 / . / net / http / http_cache_unittest.cc
blob: 46dad2760b4e4160c69bc4b86acb0965f69f06e3 [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 <algorithm>
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/memory/scoped_vector.h"
#include "base/message_loop/message_loop.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "net/base/cache_type.h"
#include "net/base/host_port_pair.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/net_log_unittest.h"
#include "net/base/upload_bytes_element_reader.h"
#include "net/base/upload_data_stream.h"
#include "net/cert/cert_status_flags.h"
#include "net/disk_cache/disk_cache.h"
#include "net/http/http_byte_range.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/socket/client_socket_handle.h"
#include "net/ssl/ssl_cert_request_info.h"
#include "net/websockets/websocket_handshake_stream_base.h"
#include "testing/gtest/include/gtest/gtest.h"
using base::Time;
namespace {
// Tests the load timing values of a request that goes through a
// MockNetworkTransaction.
void TestLoadTimingNetworkRequest(const net::LoadTimingInfo& load_timing_info) {
EXPECT_FALSE(load_timing_info.socket_reused);
EXPECT_NE(net::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());
net::ExpectConnectTimingHasTimes(load_timing_info.connect_timing,
net::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 net::LoadTimingInfo& load_timing_info) {
EXPECT_FALSE(load_timing_info.socket_reused);
EXPECT_EQ(net::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());
net::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 net::TestCompletionCallbackBase {
public:
explicit DeleteCacheCompletionCallback(MockHttpCache* cache)
: cache_(cache),
callback_(base::Bind(&DeleteCacheCompletionCallback::OnComplete,
base::Unretained(this))) {
}
const net::CompletionCallback& callback() const { return callback_; }
private:
void OnComplete(int result) {
delete cache_;
SetResult(result);
}
MockHttpCache* cache_;
net::CompletionCallback callback_;
DISALLOW_COPY_AND_ASSIGN(DeleteCacheCompletionCallback);
};
//-----------------------------------------------------------------------------
// helpers
void ReadAndVerifyTransaction(net::HttpTransaction* trans,
const MockTransaction& trans_info) {
std::string content;
int rv = ReadTransaction(trans, &content);
EXPECT_EQ(net::OK, rv);
std::string expected(trans_info.data);
EXPECT_EQ(expected, content);
}
void RunTransactionTestBase(net::HttpCache* cache,
const MockTransaction& trans_info,
const MockHttpRequest& request,
net::HttpResponseInfo* response_info,
const net::BoundNetLog& net_log,
net::LoadTimingInfo* load_timing_info,
int64* received_bytes) {
net::TestCompletionCallback callback;
// write to the cache
scoped_ptr<net::HttpTransaction> trans;
int rv = cache->CreateTransaction(net::DEFAULT_PRIORITY, &trans);
EXPECT_EQ(net::OK, rv);
ASSERT_TRUE(trans.get());
rv = trans->Start(&request, callback.callback(), net_log);
if (rv == net::ERR_IO_PENDING)
rv = callback.WaitForResult();
ASSERT_EQ(trans_info.return_code, rv);
if (net::OK != rv)
return;
const net::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 = net::LoadTimingInfo();
trans->GetLoadTimingInfo(load_timing_info);
}
ReadAndVerifyTransaction(trans.get(), trans_info);
if (received_bytes)
*received_bytes = trans->GetTotalReceivedBytes();
}
void RunTransactionTestWithRequest(net::HttpCache* cache,
const MockTransaction& trans_info,
const MockHttpRequest& request,
net::HttpResponseInfo* response_info) {
RunTransactionTestBase(cache, trans_info, request, response_info,
net::BoundNetLog(), NULL, NULL);
}
void RunTransactionTestAndGetTiming(net::HttpCache* cache,
const MockTransaction& trans_info,
const net::BoundNetLog& log,
net::LoadTimingInfo* load_timing_info) {
RunTransactionTestBase(cache, trans_info, MockHttpRequest(trans_info),
NULL, log, load_timing_info, NULL);
}
void RunTransactionTest(net::HttpCache* cache,
const MockTransaction& trans_info) {
RunTransactionTestAndGetTiming(cache, trans_info, net::BoundNetLog(), NULL);
}
void RunTransactionTestWithResponseInfo(net::HttpCache* cache,
const MockTransaction& trans_info,
net::HttpResponseInfo* response) {
RunTransactionTestWithRequest(cache, trans_info, MockHttpRequest(trans_info),
response);
}
void RunTransactionTestWithResponseInfoAndGetTiming(
net::HttpCache* cache,
const MockTransaction& trans_info,
net::HttpResponseInfo* response,
const net::BoundNetLog& log,
net::LoadTimingInfo* load_timing_info) {
RunTransactionTestBase(cache, trans_info, MockHttpRequest(trans_info),
response, log, load_timing_info, NULL);
}
void RunTransactionTestWithResponse(net::HttpCache* cache,
const MockTransaction& trans_info,
std::string* response_headers) {
net::HttpResponseInfo response;
RunTransactionTestWithResponseInfo(cache, trans_info, &response);
response.headers->GetNormalizedHeaders(response_headers);
}
void RunTransactionTestWithResponseAndGetTiming(
net::HttpCache* cache,
const MockTransaction& trans_info,
std::string* response_headers,
const net::BoundNetLog& log,
net::LoadTimingInfo* load_timing_info) {
net::HttpResponseInfo response;
RunTransactionTestBase(cache, trans_info, MockHttpRequest(trans_info),
&response, log, load_timing_info, NULL);
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 net::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(),
"",
net::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,
0,
net::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; }
static void RangeHandler(const net::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 net::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));
if (request->extra_headers.HasHeader("X-Require-Mock-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<net::HttpByteRange> ranges;
std::string range_header;
if (!request->extra_headers.GetHeader(
net::HttpRequestHeaders::kRange, &range_header) ||
!net::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.
net::HttpByteRange byte_range = ranges[0];
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,
net::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,
0,
net::OK
};
// Verifies the response headers (|response|) match a partial content
// response for the range starting at |start| and ending at |end|.
void Verify206Response(std::string response, int start, int end) {
std::string raw_headers(net::HttpUtil::AssembleRawHeaders(response.data(),
response.size()));
scoped_refptr<net::HttpResponseHeaders> headers(
new net::HttpResponseHeaders(raw_headers));
ASSERT_EQ(206, headers->response_code());
int64 range_start, range_end, object_size;
ASSERT_TRUE(
headers->GetContentRange(&range_start, &range_end, &object_size));
int64 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 = net::HttpUtil::AssembleRawHeaders(raw_headers.data(),
raw_headers.size());
net::HttpResponseInfo response;
response.response_time = base::Time::Now();
response.request_time = base::Time::Now();
response.headers = new net::HttpResponseHeaders(raw_headers);
// Set the last argument for this to be an incomplete request.
EXPECT_TRUE(MockHttpCache::WriteResponseInfo(entry, &response, true, true));
scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(100));
int len = static_cast<int>(base::strlcpy(buf->data(),
"rg: 00-09 rg: 10-19 ", 100));
net::TestCompletionCallback cb;
int rv = entry->WriteData(1, 0, buf.get(), len, cb.callback(), true);
EXPECT_EQ(len, cb.GetResult(rv));
entry->Close();
}
// 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(net::ERR_IO_PENDING) {}
int result;
net::TestCompletionCallback callback;
scoped_ptr<net::HttpTransaction> trans;
};
class FakeWebSocketHandshakeStreamCreateHelper
: public net::WebSocketHandshakeStreamBase::CreateHelper {
public:
virtual ~FakeWebSocketHandshakeStreamCreateHelper() {}
virtual net::WebSocketHandshakeStreamBase* CreateBasicStream(
scoped_ptr<net::ClientSocketHandle> connect, bool using_proxy) OVERRIDE {
return NULL;
}
virtual net::WebSocketHandshakeStreamBase* CreateSpdyStream(
const base::WeakPtr<net::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 net::CapturingNetLog::CapturedEntry& entry) {
switch (entry.type) {
case net::NetLog::TYPE_HTTP_CACHE_GET_BACKEND:
case net::NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY:
case net::NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY:
case net::NetLog::TYPE_HTTP_CACHE_ADD_TO_ENTRY:
case net::NetLog::TYPE_HTTP_CACHE_DOOM_ENTRY:
case net::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(net::CapturingNetLog::CapturedEntryList* entries) {
entries->erase(std::remove_if(entries->begin(), entries->end(),
&ShouldIgnoreLogEntry),
entries->end());
}
} // namespace
//-----------------------------------------------------------------------------
// Tests.
TEST(HttpCache, CreateThenDestroy) {
MockHttpCache cache;
scoped_ptr<net::HttpTransaction> trans;
EXPECT_EQ(net::OK, cache.CreateTransaction(&trans));
ASSERT_TRUE(trans.get());
}
TEST(HttpCache, GetBackend) {
MockHttpCache cache(net::HttpCache::DefaultBackend::InMemory(0));
disk_cache::Backend* backend;
net::TestCompletionCallback cb;
// This will lazily initialize the backend.
int rv = cache.http_cache()->GetBackend(&backend, cb.callback());
EXPECT_EQ(net::OK, cb.GetResult(rv));
}
TEST(HttpCache, SimpleGET) {
MockHttpCache cache;
net::CapturingBoundNetLog log;
net::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();
net::CapturingBoundNetLog log;
net::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).
net::CapturingNetLog::CapturedEntryList entries;
log.GetEntries(&entries);
FilterLogEntries(&entries);
EXPECT_EQ(6u, entries.size());
EXPECT_TRUE(net::LogContainsBeginEvent(
entries, 0, net::NetLog::TYPE_HTTP_CACHE_GET_BACKEND));
EXPECT_TRUE(net::LogContainsEndEvent(
entries, 1, net::NetLog::TYPE_HTTP_CACHE_GET_BACKEND));
EXPECT_TRUE(net::LogContainsBeginEvent(
entries, 2, net::NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
EXPECT_TRUE(net::LogContainsEndEvent(
entries, 3, net::NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
EXPECT_TRUE(net::LogContainsBeginEvent(
entries, 4, net::NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY));
EXPECT_TRUE(net::LogContainsEndEvent(
entries, 5, net::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.
MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
factory->set_fail(true);
factory->FinishCreation(); // We'll complete synchronously.
MockHttpCache cache(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);
scoped_ptr<net::HttpTransaction> trans;
ASSERT_EQ(net::OK, cache.CreateTransaction(&trans));
const int kBufferSize = 10;
scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
net::ReleaseBufferCompletionCallback cb(buffer.get());
int rv = trans->Start(&request, cb.callback(), net::BoundNetLog());
EXPECT_EQ(net::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);
scoped_ptr<Context> c(new Context());
int rv = cache.CreateTransaction(&c->trans);
ASSERT_EQ(net::OK, rv);
rv = c->trans->Start(&request, c->callback.callback(), net::BoundNetLog());
EXPECT_EQ(net::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.
scoped_ptr<Context> c(new Context());
int rv = cache.CreateTransaction(&c->trans);
ASSERT_EQ(net::OK, rv);
MockHttpRequest request(kSimpleGET_Transaction);
rv = c->trans->Start(&request, c->callback.callback(), net::BoundNetLog());
EXPECT_EQ(net::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;
net::CapturingBoundNetLog log;
net::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.
net::CapturingNetLog::CapturedEntryList entries;
log.GetEntries(&entries);
FilterLogEntries(&entries);
EXPECT_EQ(8u, entries.size());
EXPECT_TRUE(net::LogContainsBeginEvent(
entries, 0, net::NetLog::TYPE_HTTP_CACHE_GET_BACKEND));
EXPECT_TRUE(net::LogContainsEndEvent(
entries, 1, net::NetLog::TYPE_HTTP_CACHE_GET_BACKEND));
EXPECT_TRUE(net::LogContainsBeginEvent(
entries, 2, net::NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
EXPECT_TRUE(net::LogContainsEndEvent(
entries, 3, net::NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
EXPECT_TRUE(net::LogContainsBeginEvent(
entries, 4, net::NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY));
EXPECT_TRUE(net::LogContainsEndEvent(
entries, 5, net::NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY));
EXPECT_TRUE(net::LogContainsBeginEvent(
entries, 6, net::NetLog::TYPE_HTTP_CACHE_ADD_TO_ENTRY));
EXPECT_TRUE(net::LogContainsEndEvent(
entries, 7, net::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 |= net::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(net::LogContainsBeginEvent(
entries, 0, net::NetLog::TYPE_HTTP_CACHE_GET_BACKEND));
EXPECT_TRUE(net::LogContainsEndEvent(
entries, 1, net::NetLog::TYPE_HTTP_CACHE_GET_BACKEND));
EXPECT_TRUE(net::LogContainsBeginEvent(
entries, 2, net::NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
EXPECT_TRUE(net::LogContainsEndEvent(
entries, 3, net::NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
EXPECT_TRUE(net::LogContainsBeginEvent(
entries, 4, net::NetLog::TYPE_HTTP_CACHE_ADD_TO_ENTRY));
EXPECT_TRUE(net::LogContainsEndEvent(
entries, 5, net::NetLog::TYPE_HTTP_CACHE_ADD_TO_ENTRY));
EXPECT_TRUE(net::LogContainsBeginEvent(
entries, 6, net::NetLog::TYPE_HTTP_CACHE_READ_INFO));
EXPECT_TRUE(net::LogContainsEndEvent(
entries, 7, net::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 |= net::LOAD_ONLY_FROM_CACHE;
MockHttpRequest request(transaction);
net::TestCompletionCallback callback;
scoped_ptr<net::HttpTransaction> trans;
ASSERT_EQ(net::OK, cache.CreateTransaction(&trans));
int rv = trans->Start(&request, callback.callback(), net::BoundNetLog());
if (rv == net::ERR_IO_PENDING)
rv = callback.WaitForResult();
ASSERT_EQ(net::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 |= net::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 |= net::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 |= net::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 |= net::LOAD_PREFERRING_CACHE;
transaction.request_headers = "Foo: none\r\n";
net::CapturingBoundNetLog log;
net::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 LOAD_FROM_CACHE_IF_OFFLINE returns proper response on
// network success
TEST(HttpCache, SimpleGET_CacheOverride_Network) {
MockHttpCache cache;
// Prime cache.
MockTransaction transaction(kSimpleGET_Transaction);
transaction.load_flags |= net::LOAD_FROM_CACHE_IF_OFFLINE;
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);
// Re-run transaction; make sure the result came from the network,
// not the cache.
transaction.data = "Changed data.";
AddMockTransaction(&transaction);
net::HttpResponseInfo response_info;
RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
&response_info);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_FALSE(response_info.server_data_unavailable);
EXPECT_TRUE(response_info.network_accessed);
RemoveMockTransaction(&transaction);
}
// Tests that LOAD_FROM_CACHE_IF_OFFLINE returns proper response on
// offline failure
TEST(HttpCache, SimpleGET_CacheOverride_Offline) {
MockHttpCache cache;
// Prime cache.
MockTransaction transaction(kSimpleGET_Transaction);
transaction.load_flags |= net::LOAD_FROM_CACHE_IF_OFFLINE;
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 offline error; should return cache entry above +
// flag signalling stale data.
transaction.return_code = net::ERR_NAME_NOT_RESOLVED;
AddMockTransaction(&transaction);
MockHttpRequest request(transaction);
net::TestCompletionCallback callback;
scoped_ptr<net::HttpTransaction> trans;
ASSERT_EQ(net::OK, cache.CreateTransaction(&trans));
int rv = trans->Start(&request, callback.callback(), net::BoundNetLog());
EXPECT_EQ(net::OK, callback.GetResult(rv));
const net::HttpResponseInfo* response_info = trans->GetResponseInfo();
ASSERT_TRUE(response_info);
EXPECT_TRUE(response_info->server_data_unavailable);
EXPECT_TRUE(response_info->was_cached);
EXPECT_FALSE(response_info->network_accessed);
ReadAndVerifyTransaction(trans.get(), transaction);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
RemoveMockTransaction(&transaction);
}
// Tests that LOAD_FROM_CACHE_IF_OFFLINE returns proper response on
// non-offline failure.
TEST(HttpCache, SimpleGET_CacheOverride_NonOffline) {
MockHttpCache cache;
// Prime cache.
MockTransaction transaction(kSimpleGET_Transaction);
transaction.load_flags |= net::LOAD_FROM_CACHE_IF_OFFLINE;
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 non-offline error; should fail with that error.
transaction.return_code = net::ERR_PROXY_CONNECTION_FAILED;
AddMockTransaction(&transaction);
net::HttpResponseInfo response_info2;
RunTransactionTestWithResponseInfo(cache.http_cache(), transaction,
&response_info2);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
EXPECT_FALSE(response_info2.server_data_unavailable);
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 = net::ERR_FAILED;
AddMockTransaction(&transaction);
MockHttpRequest request(transaction);
net::TestCompletionCallback callback;
scoped_ptr<net::HttpTransaction> trans;
int rv = cache.http_cache()->CreateTransaction(net::DEFAULT_PRIORITY, &trans);
EXPECT_EQ(net::OK, rv);
ASSERT_TRUE(trans.get());
rv = trans->Start(&request, callback.callback(), net::BoundNetLog());
EXPECT_EQ(net::ERR_FAILED, callback.GetResult(rv));
const net::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
net::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.
net::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 |= net::LOAD_BYPASS_CACHE;
net::CapturingBoundNetLog log;
net::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.
net::CapturingNetLog::CapturedEntryList entries;
log.GetEntries(&entries);
FilterLogEntries(&entries);
EXPECT_EQ(8u, entries.size());
EXPECT_TRUE(net::LogContainsBeginEvent(
entries, 0, net::NetLog::TYPE_HTTP_CACHE_GET_BACKEND));
EXPECT_TRUE(net::LogContainsEndEvent(
entries, 1, net::NetLog::TYPE_HTTP_CACHE_GET_BACKEND));
EXPECT_TRUE(net::LogContainsBeginEvent(
entries, 2, net::NetLog::TYPE_HTTP_CACHE_DOOM_ENTRY));
EXPECT_TRUE(net::LogContainsEndEvent(
entries, 3, net::NetLog::TYPE_HTTP_CACHE_DOOM_ENTRY));
EXPECT_TRUE(net::LogContainsBeginEvent(
entries, 4, net::NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY));
EXPECT_TRUE(net::LogContainsEndEvent(
entries, 5, net::NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY));
EXPECT_TRUE(net::LogContainsBeginEvent(
entries, 6, net::NetLog::TYPE_HTTP_CACHE_ADD_TO_ENTRY));
EXPECT_TRUE(net::LogContainsEndEvent(
entries, 7, net::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 |= net::LOAD_VALIDATE_CACHE;
net::HttpResponseInfo response_info;
net::CapturingBoundNetLog log;
net::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 net::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(net::OK, c->result);
EXPECT_EQ(net::LOAD_STATE_IDLE, c->trans->GetLoadState());
c->result = c->trans->Start(
&request, c->callback.callback(), net::BoundNetLog());
}
// All requests are waiting for the active entry.
for (int i = 0; i < kNumTransactions; ++i) {
Context* c = context_list[i];
EXPECT_EQ(net::LOAD_STATE_WAITING_FOR_CACHE, c->trans->GetLoadState());
}
// Allow all requests to move from the Create queue to the active entry.
base::MessageLoop::current()->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(net::LOAD_STATE_IDLE, c->trans->GetLoadState());
}
for (int i = 0; i < kNumTransactions; ++i) {
Context* c = context_list[i];
if (c->result == net::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 = net::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(net::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(), net::BoundNetLog());
}
// Allow all requests to move from the Create queue to the active entry.
base::MessageLoop::current()->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(net::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(net::LOAD_STATE_IDLE,
context_list[2]->trans->GetLoadState());
EXPECT_EQ(net::LOAD_STATE_WAITING_FOR_CACHE,
context_list[3]->trans->GetLoadState());
c = context_list[1];
ASSERT_EQ(net::ERR_IO_PENDING, c->result);
c->result = c->callback.WaitForResult();
if (c->result == net::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 == net::ERR_IO_PENDING)
c->result = c->callback.WaitForResult();
if (c->result == net::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(net::HttpCache::DefaultBackend::InMemory(1024 * 1024));
MockHttpRequest request(kSimpleGET_Transaction);
MockHttpRequest writer_request(kSimpleGET_Transaction);
writer_request.load_flags = net::LOAD_BYPASS_CACHE;
ScopedVector<Context> context_list;
const int kNumTransactions = 4;
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(net::OK, c->result);
MockHttpRequest* this_request = &request;
if (i == 3)
this_request = &writer_request;
c->result = c->trans->Start(
this_request, c->callback.callback(), net::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.
delete context_list[1];
context_list.get()[1] = NULL;
for (int i = 0; i < kNumTransactions; ++i) {
if (i == 1)
continue;
Context* c = context_list[i];
ASSERT_EQ(net::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(net::OK, c->result);
c->result = c->trans->Start(
&request, c->callback.callback(), net::BoundNetLog());
}
// Allow all requests to move from the Create queue to the active entry.
base::MessageLoop::current()->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 == net::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(net::OK, c->result);
c->result = c->trans->Start(
&request, c->callback.callback(), net::BoundNetLog());
}
// Allow all requests to move from the Create queue to the active entry.
base::MessageLoop::current()->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 == net::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(net::OK, c->result);
c->result = c->trans->Start(
&request, c->callback.callback(), net::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(net::OK, c->result);
c->result = c->trans->Start(
&request, c->callback.callback(), net::BoundNetLog());
EXPECT_EQ(net::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::MessageLoop::current()->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 = net::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(net::OK, c->result);
c->result = c->trans->Start(
&request, c->callback.callback(), net::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(net::OK, cache.CreateTransaction(&c1.trans));
ASSERT_EQ(net::ERR_IO_PENDING,
c1.trans->Start(&request, c1.callback.callback(),
net::BoundNetLog()));
ASSERT_EQ(net::OK, cache.CreateTransaction(&c2.trans));
ASSERT_EQ(net::ERR_IO_PENDING,
c2.trans->Start(&request, c2.callback.callback(),
net::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);
net::TestCompletionCallback callback;
scoped_ptr<net::HttpTransaction> trans;
ASSERT_EQ(net::OK, cache.CreateTransaction(&trans));
int rv = trans->Start(&request, callback.callback(), net::BoundNetLog());
if (rv == net::ERR_IO_PENDING)
rv = callback.WaitForResult();
ASSERT_EQ(net::OK, rv);
scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
rv = trans->Read(buf.get(), 256, callback.callback());
EXPECT_EQ(net::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::MessageLoop::current()->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) {
scoped_ptr<MockHttpCache> cache(new MockHttpCache(
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(net::OK, c->result);
c->result = c->trans->Start(
&request, c->callback.callback(), net::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(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(net::OK, c->result);
}
context_list[0]->result = context_list[0]->trans->Start(
&request0, context_list[0]->callback.callback(), net::BoundNetLog());
context_list[1]->result = context_list[1]->trans->Start(
&request1, context_list[1]->callback.callback(), net::BoundNetLog());
context_list[2]->result = context_list[2]->trans->Start(
&request2, context_list[2]->callback.callback(), net::BoundNetLog());
// Just to make sure that everything is still pending.
base::MessageLoop::current()->RunUntilIdle();
// The first request should be creating the disk cache.
EXPECT_FALSE(context_list[0]->callback.have_result());
factory->FinishCreation();
base::MessageLoop::current()->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(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(net::OK, c->result);
}
context_list[0]->result = context_list[0]->trans->Start(
&request0, context_list[0]->callback.callback(), net::BoundNetLog());
context_list[1]->result = context_list[1]->trans->Start(
&request1, context_list[1]->callback.callback(), net::BoundNetLog());
context_list[2]->result = context_list[2]->trans->Start(
&request2, context_list[2]->callback.callback(), net::BoundNetLog());
// Just to make sure that everything is still pending.
base::MessageLoop::current()->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();
scoped_ptr<MockHttpCache> cache(new MockHttpCache(factory));
MockHttpRequest request(kSimpleGET_Transaction);
scoped_ptr<Context> c(new Context());
c->result = cache->CreateTransaction(&c->trans);
ASSERT_EQ(net::OK, c->result);
c->trans->Start(&request, c->callback.callback(), net::BoundNetLog());
// Just to make sure that everything is still pending.
base::MessageLoop::current()->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.
net::CompletionCallback callback = factory->callback();
scoped_ptr<disk_cache::Backend>* backend = factory->backend();
cache.reset();
base::MessageLoop::current()->RunUntilIdle();
backend->reset();
callback.Run(net::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(factory);
DeleteCacheCompletionCallback cb(cache);
disk_cache::Backend* backend;
int rv = cache->http_cache()->GetBackend(&backend, cb.callback());
EXPECT_EQ(net::ERR_IO_PENDING, rv);
// Now let's queue a regular transaction
MockHttpRequest request(kSimpleGET_Transaction);
scoped_ptr<Context> c(new Context());
c->result = cache->CreateTransaction(&c->trans);
ASSERT_EQ(net::OK, c->result);
c->trans->Start(&request, c->callback.callback(), net::BoundNetLog());
// And another direct backend request.
net::TestCompletionCallback cb2;
rv = cache->http_cache()->GetBackend(&backend, cb2.callback());
EXPECT_EQ(net::ERR_IO_PENDING, rv);
// Just to make sure that everything is still pending.
base::MessageLoop::current()->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::MessageLoop::current()->RunUntilIdle();
EXPECT_EQ(net::OK, c->callback.GetResult(c->result));
EXPECT_FALSE(cb2.have_result());
}
TEST(HttpCache, 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.
net::CapturingBoundNetLog log;
net::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 net::HttpRequestInfo* request,
std::string* response_status,
std::string* response_headers,
std::string* response_data) {
EXPECT_TRUE(
request->extra_headers.HasHeader(net::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 = net::LOAD_VALIDATE_CACHE;
transaction.handler = ETagGet_ConditionalRequest_Handler;
net::CapturingBoundNetLog log;
net::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);
}
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 net::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 net::HttpRequestInfo* request,
std::string* response_status,
std::string* response_headers,
std::string* response_data) {
if (request->extra_headers.HasHeader(net::HttpRequestHeaders::kIfNoneMatch))
s_etag_used_ = true;
if (request->extra_headers.HasHeader(
net::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, SimpleGET_LoadValidateCache_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;
net::CapturingBoundNetLog log;
net::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, SimpleGET_LoadValidateCache_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";
net::CapturingBoundNetLog log;
net::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, SimpleGET_LoadDontValidateCache_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";
net::CapturingBoundNetLog log;
net::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);
}
static void ETagGet_UnconditionalRequest_Handler(
const net::HttpRequestInfo* request,
std::string* response_status,
std::string* response_headers,
std::string* response_data) {
EXPECT_FALSE(
request->extra_headers.HasHeader(net::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 = net::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 = net::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 net::HttpRequestInfo* request,
std::string* response_status,
std::string* response_headers,
std::string* response_data) {
EXPECT_TRUE(
request->extra_headers.HasHeader(net::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 = net::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 = net::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 = net::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 = net::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.
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(HttpCache, 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(HttpCache, 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(HttpCache, 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(HttpCache, 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(HttpCache, ConditionalizedRequestUpdatesCache10) {