Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(416)

Unified Diff: net/http/http_cache_unittest.cc

Issue 992733002: Remove //net (except for Android test stuff) and sdch (Closed) Base URL: git@github.com:domokit/mojo.git@master
Patch Set: Created 5 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « net/http/http_cache_transaction.cc ('k') | net/http/http_chunked_decoder.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/http/http_cache_unittest.cc
diff --git a/net/http/http_cache_unittest.cc b/net/http/http_cache_unittest.cc
deleted file mode 100644
index 66349b61d3f17cf07d03399c0bab346671b54c04..0000000000000000000000000000000000000000
--- a/net/http/http_cache_unittest.cc
+++ /dev/null
@@ -1,7778 +0,0 @@
-// 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/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/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/cert/cert_status_flags.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/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 RunTransactionTestWithLog(net::HttpCache* cache,
- const MockTransaction& trans_info,
- const net::BoundNetLog& log) {
- RunTransactionTestAndGetTiming(cache, trans_info, log, 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; }
-
- // 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-Return-Default-Range -> assume 40-49 was requested.
- 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 (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,
- 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
-};
-
-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(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:
- ~FakeWebSocketHandshakeStreamCreateHelper() override {}
- net::WebSocketHandshakeStreamBase* CreateBasicStream(
- scoped_ptr<net::ClientSocketHandle> connect,
- bool using_proxy) override {
- return NULL;
- }
- 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());
-}
-
-bool LogContainsEventType(const net::CapturingBoundNetLog& log,
- net::NetLog::EventType expected) {
- net::CapturingNetLog::CapturedEntryList 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;
-
- 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) {
- static const Response kNetResponse1 = {
- "HTTP/1.1 200 OK",
- "Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
- "Etag: \"Foo1\"\n"
- "Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
- "body1"
- };
-
- // Second network response for |kUrl|.
- static const Response kNetResponse2 = {
- "HTTP/1.1 200 OK",
- "Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
- "Etag: \"Foo2\"\n"
- "Last-Modified: Fri, 03 Jul 2009 02:14:27 GMT\n",
- "body2"
- };
-
- // The modification date doesn't match what we have stored.
- const char kExtraRequestHeaders[] =
- "If-Modified-Since: Fri, 08 Feb 2008 22:38:21 GMT\r\n"
- "If-None-Match: \"Foo1\"\r\n";
-
- ConditionalizedRequestUpdatesCacheHelper(
- kNetResponse1, kNetResponse2, kNetResponse1, kExtraRequestHeaders);
-}
-
-TEST(HttpCache, UrlContainingHash) {
- MockHttpCache cache;
-
- // Do a typical GET request -- should write an entry into our cache.
- MockTransaction trans(kTypicalGET_Transaction);
- RunTransactionTest(cache.http_cache(), trans);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Request the same URL, but this time with a reference section (hash).
- // Since the cache key strips the hash sections, this should be a cache hit.
- std::string url_with_hash = std::string(trans.url) + "#multiple#hashes";
- trans.url = url_with_hash.c_str();
- trans.load_flags = net::LOAD_ONLY_FROM_CACHE;
-
- RunTransactionTest(cache.http_cache(), trans);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-}
-
-// Tests that we skip the cache for POST requests that do not have an upload
-// identifier.
-TEST(HttpCache, SimplePOST_SkipsCache) {
- MockHttpCache cache;
-
- RunTransactionTest(cache.http_cache(), kSimplePOST_Transaction);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(0, cache.disk_cache()->create_count());
-}
-
-// Tests POST handling with a disabled cache (no DCHECK).
-TEST(HttpCache, SimplePOST_DisabledCache) {
- MockHttpCache cache;
- cache.http_cache()->set_mode(net::HttpCache::Mode::DISABLE);
-
- RunTransactionTest(cache.http_cache(), kSimplePOST_Transaction);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(0, cache.disk_cache()->create_count());
-}
-
-TEST(HttpCache, SimplePOST_LoadOnlyFromCache_Miss) {
- MockHttpCache cache;
-
- MockTransaction transaction(kSimplePOST_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));
- ASSERT_TRUE(trans.get());
-
- int rv = trans->Start(&request, callback.callback(), net::BoundNetLog());
- ASSERT_EQ(net::ERR_CACHE_MISS, callback.GetResult(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, SimplePOST_LoadOnlyFromCache_Hit) {
- MockHttpCache cache;
-
- // Test that we hit the cache for POST requests.
-
- MockTransaction transaction(kSimplePOST_Transaction);
-
- const int64 kUploadId = 1; // Just a dummy value.
-
- ScopedVector<net::UploadElementReader> element_readers;
- element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
- net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(),
- kUploadId);
- MockHttpRequest request(transaction);
- request.upload_data_stream = &upload_data_stream;
-
- // Populate the cache.
- RunTransactionTestWithRequest(cache.http_cache(), transaction, request, NULL);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Load from cache.
- request.load_flags |= net::LOAD_ONLY_FROM_CACHE;
- RunTransactionTestWithRequest(cache.http_cache(), transaction, request, NULL);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-}
-
-// Test that we don't hit the cache for POST requests if there is a byte range.
-TEST(HttpCache, SimplePOST_WithRanges) {
- MockHttpCache cache;
-
- MockTransaction transaction(kSimplePOST_Transaction);
- transaction.request_headers = "Range: bytes = 0-4\r\n";
-
- const int64 kUploadId = 1; // Just a dummy value.
-
- ScopedVector<net::UploadElementReader> element_readers;
- element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
- net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(),
- kUploadId);
-
- MockHttpRequest request(transaction);
- request.upload_data_stream = &upload_data_stream;
-
- // Attempt to populate the cache.
- RunTransactionTestWithRequest(cache.http_cache(), transaction, request, NULL);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(0, cache.disk_cache()->create_count());
-}
-
-// Tests that a POST is cached separately from a previously cached GET.
-TEST(HttpCache, SimplePOST_SeparateCache) {
- MockHttpCache cache;
-
- ScopedVector<net::UploadElementReader> element_readers;
- element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
- net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 1);
-
- MockTransaction transaction(kSimplePOST_Transaction);
- MockHttpRequest req1(transaction);
- req1.upload_data_stream = &upload_data_stream;
-
- RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- transaction.method = "GET";
- MockHttpRequest req2(transaction);
-
- RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, NULL);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-}
-
-// Tests that a successful POST invalidates a previously cached GET.
-TEST(HttpCache, SimplePOST_Invalidate_205) {
- MockHttpCache cache;
-
- MockTransaction transaction(kSimpleGET_Transaction);
- AddMockTransaction(&transaction);
- MockHttpRequest req1(transaction);
-
- // Attempt to populate the cache.
- RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- ScopedVector<net::UploadElementReader> element_readers;
- element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
- net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 1);
-
- transaction.method = "POST";
- transaction.status = "HTTP/1.1 205 No Content";
- MockHttpRequest req2(transaction);
- req2.upload_data_stream = &upload_data_stream;
-
- RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, NULL);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-
- RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
-
- EXPECT_EQ(3, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(3, cache.disk_cache()->create_count());
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that a successful POST invalidates a previously cached GET, even when
-// there is no upload identifier.
-TEST(HttpCache, SimplePOST_NoUploadId_Invalidate_205) {
- MockHttpCache cache;
-
- MockTransaction transaction(kSimpleGET_Transaction);
- AddMockTransaction(&transaction);
- MockHttpRequest req1(transaction);
-
- // Attempt to populate the cache.
- RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- ScopedVector<net::UploadElementReader> element_readers;
- element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
- net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
-
- transaction.method = "POST";
- transaction.status = "HTTP/1.1 205 No Content";
- MockHttpRequest req2(transaction);
- req2.upload_data_stream = &upload_data_stream;
-
- RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, NULL);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
-
- EXPECT_EQ(3, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that processing a POST before creating the backend doesn't crash.
-TEST(HttpCache, SimplePOST_NoUploadId_NoBackend) {
- // This will initialize a cache object with NULL backend.
- MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
- factory->set_fail(true);
- factory->FinishCreation();
- MockHttpCache cache(factory);
-
- ScopedVector<net::UploadElementReader> element_readers;
- element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
- net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
-
- MockTransaction transaction(kSimplePOST_Transaction);
- AddMockTransaction(&transaction);
- MockHttpRequest req(transaction);
- req.upload_data_stream = &upload_data_stream;
-
- RunTransactionTestWithRequest(cache.http_cache(), transaction, req, NULL);
-
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that we don't invalidate entries as a result of a failed POST.
-TEST(HttpCache, SimplePOST_DontInvalidate_100) {
- MockHttpCache cache;
-
- MockTransaction transaction(kSimpleGET_Transaction);
- AddMockTransaction(&transaction);
- MockHttpRequest req1(transaction);
-
- // Attempt to populate the cache.
- RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- ScopedVector<net::UploadElementReader> element_readers;
- element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
- net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 1);
-
- transaction.method = "POST";
- transaction.status = "HTTP/1.1 100 Continue";
- MockHttpRequest req2(transaction);
- req2.upload_data_stream = &upload_data_stream;
-
- RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, NULL);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-
- RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that a HEAD request is not cached by itself.
-TEST(HttpCache, SimpleHEAD_LoadOnlyFromCache_Miss) {
- MockHttpCache cache;
- MockTransaction transaction(kSimplePOST_Transaction);
- AddMockTransaction(&transaction);
- transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
- transaction.method = "HEAD";
-
- MockHttpRequest request(transaction);
- net::TestCompletionCallback callback;
-
- scoped_ptr<net::HttpTransaction> trans;
- ASSERT_EQ(net::OK, cache.CreateTransaction(&trans));
- ASSERT_TRUE(trans.get());
-
- int rv = trans->Start(&request, callback.callback(), net::BoundNetLog());
- ASSERT_EQ(net::ERR_CACHE_MISS, callback.GetResult(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());
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that a HEAD request is served from a cached GET.
-TEST(HttpCache, SimpleHEAD_LoadOnlyFromCache_Hit) {
- MockHttpCache cache;
- MockTransaction transaction(kSimpleGET_Transaction);
- AddMockTransaction(&transaction);
-
- // Populate the cache.
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Load from cache.
- transaction.method = "HEAD";
- transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
- transaction.data = "";
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that a read-only request served from the cache preserves CL.
-TEST(HttpCache, SimpleHEAD_ContentLengthOnHit_Read) {
- MockHttpCache cache;
- MockTransaction transaction(kSimpleGET_Transaction);
- AddMockTransaction(&transaction);
- transaction.response_headers = "Content-Length: 42\n";
-
- // Populate the cache.
- RunTransactionTest(cache.http_cache(), transaction);
-
- // Load from cache.
- transaction.method = "HEAD";
- transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
- transaction.data = "";
- std::string headers;
-
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- EXPECT_EQ("HTTP/1.1 200 OK\nContent-Length: 42\n", headers);
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that a read-write request served from the cache preserves CL.
-TEST(HttpCache, ETagHEAD_ContentLengthOnHit_ReadWrite) {
- MockHttpCache cache;
- MockTransaction transaction(kETagGET_Transaction);
- AddMockTransaction(&transaction);
- std::string server_headers(kETagGET_Transaction.response_headers);
- server_headers.append("Content-Length: 42\n");
- transaction.response_headers = server_headers.data();
-
- // Populate the cache.
- RunTransactionTest(cache.http_cache(), transaction);
-
- // Load from cache.
- transaction.method = "HEAD";
- transaction.data = "";
- std::string headers;
-
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- EXPECT_NE(std::string::npos, headers.find("Content-Length: 42\n"));
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that a HEAD request that includes byte ranges bypasses the cache.
-TEST(HttpCache, SimpleHEAD_WithRanges) {
- MockHttpCache cache;
- MockTransaction transaction(kSimpleGET_Transaction);
- AddMockTransaction(&transaction);
-
- // Populate the cache.
- RunTransactionTest(cache.http_cache(), transaction);
-
- // Load from cache.
- transaction.method = "HEAD";
- transaction.request_headers = "Range: bytes = 0-4\r\n";
- transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
- transaction.return_code = net::ERR_CACHE_MISS;
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that a HEAD request can be served from a partialy cached resource.
-TEST(HttpCache, SimpleHEAD_WithCachedRanges) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
-
- // Write to the cache (40-49).
- RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-
- MockTransaction transaction(kSimpleGET_Transaction);
-
- transaction.url = kRangeGET_TransactionOK.url;
- transaction.method = "HEAD";
- transaction.data = "";
- AddMockTransaction(&transaction);
- std::string headers;
-
- // Load from cache.
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- EXPECT_NE(std::string::npos, headers.find("HTTP/1.1 200 OK\n"));
- EXPECT_NE(std::string::npos, headers.find("Content-Length: 80\n"));
- EXPECT_EQ(std::string::npos, headers.find("Content-Range"));
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that a HEAD request can be served from a truncated resource.
-TEST(HttpCache, SimpleHEAD_WithTruncatedEntry) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
-
- std::string raw_headers("HTTP/1.1 200 OK\n"
- "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
- "ETag: \"foo\"\n"
- "Accept-Ranges: bytes\n"
- "Content-Length: 80\n");
- CreateTruncatedEntry(raw_headers, &cache);
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-
- MockTransaction transaction(kSimpleGET_Transaction);
-
- transaction.url = kRangeGET_TransactionOK.url;
- transaction.method = "HEAD";
- transaction.data = "";
- AddMockTransaction(&transaction);
- std::string headers;
-
- // Load from cache.
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- EXPECT_NE(std::string::npos, headers.find("HTTP/1.1 200 OK\n"));
- EXPECT_NE(std::string::npos, headers.find("Content-Length: 80\n"));
- EXPECT_EQ(std::string::npos, headers.find("Content-Range"));
- EXPECT_EQ(0, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that a HEAD request updates the cached response.
-TEST(HttpCache, TypicalHEAD_UpdatesResponse) {
- MockHttpCache cache;
- MockTransaction transaction(kTypicalGET_Transaction);
- AddMockTransaction(&transaction);
-
- // Populate the cache.
- RunTransactionTest(cache.http_cache(), transaction);
-
- // Update the cache.
- transaction.method = "HEAD";
- transaction.response_headers = "Foo: bar\n";
- transaction.data = "";
- transaction.status = "HTTP/1.1 304 Not Modified\n";
- std::string headers;
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
- RemoveMockTransaction(&transaction);
-
- EXPECT_NE(std::string::npos, headers.find("HTTP/1.1 200 OK\n"));
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
-
- MockTransaction transaction2(kTypicalGET_Transaction);
- AddMockTransaction(&transaction2);
-
- // Make sure we are done with the previous transaction.
- base::MessageLoop::current()->RunUntilIdle();
-
- // Load from the cache.
- transaction2.load_flags |= net::LOAD_ONLY_FROM_CACHE;
- RunTransactionTestWithResponse(cache.http_cache(), transaction2, &headers);
-
- EXPECT_NE(std::string::npos, headers.find("Foo: bar\n"));
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(2, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
- RemoveMockTransaction(&transaction2);
-}
-
-// Tests that an externally conditionalized HEAD request updates the cache.
-TEST(HttpCache, TypicalHEAD_ConditionalizedRequestUpdatesResponse) {
- MockHttpCache cache;
- MockTransaction transaction(kTypicalGET_Transaction);
- AddMockTransaction(&transaction);
-
- // Populate the cache.
- RunTransactionTest(cache.http_cache(), transaction);
-
- // Update the cache.
- transaction.method = "HEAD";
- transaction.request_headers =
- "If-Modified-Since: Wed, 28 Nov 2007 00:40:09 GMT\r\n";
- transaction.response_headers = "Foo: bar\n";
- transaction.data = "";
- transaction.status = "HTTP/1.1 304 Not Modified\n";
- std::string headers;
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
- RemoveMockTransaction(&transaction);
-
- EXPECT_NE(std::string::npos, headers.find("HTTP/1.1 304 Not Modified\n"));
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
-
- MockTransaction transaction2(kTypicalGET_Transaction);
- AddMockTransaction(&transaction2);
-
- // Make sure we are done with the previous transaction.
- base::MessageLoop::current()->RunUntilIdle();
-
- // Load from the cache.
- transaction2.load_flags |= net::LOAD_ONLY_FROM_CACHE;
- RunTransactionTestWithResponse(cache.http_cache(), transaction2, &headers);
-
- EXPECT_NE(std::string::npos, headers.find("Foo: bar\n"));
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(2, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
- RemoveMockTransaction(&transaction2);
-}
-
-// Tests that a HEAD request invalidates an old cached entry.
-TEST(HttpCache, SimpleHEAD_InvalidatesEntry) {
- MockHttpCache cache;
- MockTransaction transaction(kTypicalGET_Transaction);
- AddMockTransaction(&transaction);
-
- // Populate the cache.
- RunTransactionTest(cache.http_cache(), transaction);
-
- // Update the cache.
- transaction.method = "HEAD";
- transaction.data = "";
- RunTransactionTest(cache.http_cache(), transaction);
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
-
- // Load from the cache.
- transaction.method = "GET";
- transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
- transaction.return_code = net::ERR_CACHE_MISS;
- RunTransactionTest(cache.http_cache(), transaction);
-
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that we do not cache the response of a PUT.
-TEST(HttpCache, SimplePUT_Miss) {
- MockHttpCache cache;
-
- MockTransaction transaction(kSimplePOST_Transaction);
- transaction.method = "PUT";
-
- ScopedVector<net::UploadElementReader> element_readers;
- element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
- net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
-
- MockHttpRequest request(transaction);
- request.upload_data_stream = &upload_data_stream;
-
- // Attempt to populate the cache.
- RunTransactionTestWithRequest(cache.http_cache(), transaction, request, NULL);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(0, cache.disk_cache()->create_count());
-}
-
-// Tests that we invalidate entries as a result of a PUT.
-TEST(HttpCache, SimplePUT_Invalidate) {
- MockHttpCache cache;
-
- MockTransaction transaction(kSimpleGET_Transaction);
- MockHttpRequest req1(transaction);
-
- // Attempt to populate the cache.
- RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- ScopedVector<net::UploadElementReader> element_readers;
- element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
- net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
-
- transaction.method = "PUT";
- MockHttpRequest req2(transaction);
- req2.upload_data_stream = &upload_data_stream;
-
- RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, NULL);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
-
- EXPECT_EQ(3, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-}
-
-// Tests that we invalidate entries as a result of a PUT.
-TEST(HttpCache, SimplePUT_Invalidate_305) {
- MockHttpCache cache;
-
- MockTransaction transaction(kSimpleGET_Transaction);
- AddMockTransaction(&transaction);
- MockHttpRequest req1(transaction);
-
- // Attempt to populate the cache.
- RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- ScopedVector<net::UploadElementReader> element_readers;
- element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
- net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
-
- transaction.method = "PUT";
- transaction.status = "HTTP/1.1 305 Use Proxy";
- MockHttpRequest req2(transaction);
- req2.upload_data_stream = &upload_data_stream;
-
- RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, NULL);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
-
- EXPECT_EQ(3, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that we don't invalidate entries as a result of a failed PUT.
-TEST(HttpCache, SimplePUT_DontInvalidate_404) {
- MockHttpCache cache;
-
- MockTransaction transaction(kSimpleGET_Transaction);
- AddMockTransaction(&transaction);
- MockHttpRequest req1(transaction);
-
- // Attempt to populate the cache.
- RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- ScopedVector<net::UploadElementReader> element_readers;
- element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
- net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
-
- transaction.method = "PUT";
- transaction.status = "HTTP/1.1 404 Not Found";
- MockHttpRequest req2(transaction);
- req2.upload_data_stream = &upload_data_stream;
-
- RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, NULL);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(2, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that we do not cache the response of a DELETE.
-TEST(HttpCache, SimpleDELETE_Miss) {
- MockHttpCache cache;
-
- MockTransaction transaction(kSimplePOST_Transaction);
- transaction.method = "DELETE";
-
- ScopedVector<net::UploadElementReader> element_readers;
- element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
- net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
-
- MockHttpRequest request(transaction);
- request.upload_data_stream = &upload_data_stream;
-
- // Attempt to populate the cache.
- RunTransactionTestWithRequest(cache.http_cache(), transaction, request, NULL);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(0, cache.disk_cache()->create_count());
-}
-
-// Tests that we invalidate entries as a result of a DELETE.
-TEST(HttpCache, SimpleDELETE_Invalidate) {
- MockHttpCache cache;
-
- MockTransaction transaction(kSimpleGET_Transaction);
- MockHttpRequest req1(transaction);
-
- // Attempt to populate the cache.
- RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- ScopedVector<net::UploadElementReader> element_readers;
- element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
- net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
-
- transaction.method = "DELETE";
- MockHttpRequest req2(transaction);
- req2.upload_data_stream = &upload_data_stream;
-
- RunTransactionTestWithRequest(cache.http_cache(), transaction, req2, NULL);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- RunTransactionTestWithRequest(cache.http_cache(), transaction, req1, NULL);
-
- EXPECT_EQ(3, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-}
-
-// Tests that we invalidate entries as a result of a DELETE.
-TEST(HttpCache, SimpleDELETE_Invalidate_301) {
- MockHttpCache cache;
-
- MockTransaction transaction(kSimpleGET_Transaction);
- AddMockTransaction(&transaction);
-
- // Attempt to populate the cache.
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- transaction.method = "DELETE";
- transaction.status = "HTTP/1.1 301 Moved Permanently ";
-
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- transaction.method = "GET";
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(3, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that we don't invalidate entries as a result of a failed DELETE.
-TEST(HttpCache, SimpleDELETE_DontInvalidate_416) {
- MockHttpCache cache;
-
- MockTransaction transaction(kSimpleGET_Transaction);
- AddMockTransaction(&transaction);
-
- // Attempt to populate the cache.
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- transaction.method = "DELETE";
- transaction.status = "HTTP/1.1 416 Requested Range Not Satisfiable";
-
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- transaction.method = "GET";
- transaction.status = "HTTP/1.1 200 OK";
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(2, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that we don't invalidate entries after a failed network transaction.
-TEST(HttpCache, SimpleGET_DontInvalidateOnFailure) {
- MockHttpCache cache;
-
- // Populate the cache.
- RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
-
- // Fail the network request.
- MockTransaction transaction(kSimpleGET_Transaction);
- transaction.return_code = net::ERR_FAILED;
- transaction.load_flags |= net::LOAD_VALIDATE_CACHE;
-
- AddMockTransaction(&transaction);
- RunTransactionTest(cache.http_cache(), transaction);
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- RemoveMockTransaction(&transaction);
-
- transaction.load_flags = net::LOAD_ONLY_FROM_CACHE;
- transaction.return_code = net::OK;
- AddMockTransaction(&transaction);
- RunTransactionTest(cache.http_cache(), transaction);
-
- // Make sure the transaction didn't reach the network.
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- RemoveMockTransaction(&transaction);
-}
-
-TEST(HttpCache, RangeGET_SkipsCache) {
- MockHttpCache cache;
-
- // Test that we skip the cache for range GET requests. Eventually, we will
- // want to cache these, but we'll still have cases where skipping the cache
- // makes sense, so we want to make sure that it works properly.
-
- RunTransactionTest(cache.http_cache(), kRangeGET_Transaction);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(0, cache.disk_cache()->create_count());
-
- MockTransaction transaction(kSimpleGET_Transaction);
- transaction.request_headers = "If-None-Match: foo\r\n";
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(0, cache.disk_cache()->create_count());
-
- transaction.request_headers =
- "If-Modified-Since: Wed, 28 Nov 2007 00:45:20 GMT\r\n";
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(3, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(0, cache.disk_cache()->create_count());
-}
-
-// Test that we skip the cache for range requests that include a validation
-// header.
-TEST(HttpCache, RangeGET_SkipsCache2) {
- MockHttpCache cache;
-
- MockTransaction transaction(kRangeGET_Transaction);
- transaction.request_headers = "If-None-Match: foo\r\n"
- EXTRA_HEADER
- "Range: bytes = 40-49\r\n";
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(0, cache.disk_cache()->create_count());
-
- transaction.request_headers =
- "If-Modified-Since: Wed, 28 Nov 2007 00:45:20 GMT\r\n"
- EXTRA_HEADER
- "Range: bytes = 40-49\r\n";
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(0, cache.disk_cache()->create_count());
-
- transaction.request_headers = "If-Range: bla\r\n"
- EXTRA_HEADER
- "Range: bytes = 40-49\r\n";
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(3, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(0, cache.disk_cache()->create_count());
-}
-
-TEST(HttpCache, SimpleGET_DoesntLogHeaders) {
- MockHttpCache cache;
-
- net::CapturingBoundNetLog log;
- RunTransactionTestWithLog(cache.http_cache(), kSimpleGET_Transaction,
- log.bound());
-
- EXPECT_FALSE(LogContainsEventType(
- log, net::NetLog::TYPE_HTTP_CACHE_CALLER_REQUEST_HEADERS));
-}
-
-TEST(HttpCache, RangeGET_LogsHeaders) {
- MockHttpCache cache;
-
- net::CapturingBoundNetLog log;
- RunTransactionTestWithLog(cache.http_cache(), kRangeGET_Transaction,
- log.bound());
-
- EXPECT_TRUE(LogContainsEventType(
- log, net::NetLog::TYPE_HTTP_CACHE_CALLER_REQUEST_HEADERS));
-}
-
-TEST(HttpCache, ExternalValidation_LogsHeaders) {
- MockHttpCache cache;
-
- net::CapturingBoundNetLog log;
- MockTransaction transaction(kSimpleGET_Transaction);
- transaction.request_headers = "If-None-Match: foo\r\n" EXTRA_HEADER;
- RunTransactionTestWithLog(cache.http_cache(), transaction, log.bound());
-
- EXPECT_TRUE(LogContainsEventType(
- log, net::NetLog::TYPE_HTTP_CACHE_CALLER_REQUEST_HEADERS));
-}
-
-TEST(HttpCache, SpecialHeaders_LogsHeaders) {
- MockHttpCache cache;
-
- net::CapturingBoundNetLog log;
- MockTransaction transaction(kSimpleGET_Transaction);
- transaction.request_headers = "cache-control: no-cache\r\n" EXTRA_HEADER;
- RunTransactionTestWithLog(cache.http_cache(), transaction, log.bound());
-
- EXPECT_TRUE(LogContainsEventType(
- log, net::NetLog::TYPE_HTTP_CACHE_CALLER_REQUEST_HEADERS));
-}
-
-// Tests that receiving 206 for a regular request is handled correctly.
-TEST(HttpCache, GET_Crazy206) {
- MockHttpCache cache;
-
- // Write to the cache.
- MockTransaction transaction(kRangeGET_TransactionOK);
- AddMockTransaction(&transaction);
- transaction.request_headers = EXTRA_HEADER;
- transaction.handler = NULL;
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // This should read again from the net.
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that receiving 416 for a regular request is handled correctly.
-TEST(HttpCache, GET_Crazy416) {
- MockHttpCache cache;
-
- // Write to the cache.
- MockTransaction transaction(kSimpleGET_Transaction);
- AddMockTransaction(&transaction);
- transaction.status = "HTTP/1.1 416 Requested Range Not Satisfiable";
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that we don't store partial responses that can't be validated.
-TEST(HttpCache, RangeGET_NoStrongValidators) {
- MockHttpCache cache;
- std::string headers;
-
- // Attempt to write to the cache (40-49).
- ScopedMockTransaction transaction(kRangeGET_TransactionOK);
- transaction.response_headers = "Content-Length: 10\n"
- "Cache-Control: max-age=3600\n"
- "ETag: w/\"foo\"\n";
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Now verify that there's no cached data.
- RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
- &headers);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-}
-
-// Tests failures to conditionalize byte range requests.
-TEST(HttpCache, RangeGET_NoConditionalization) {
- MockHttpCache cache;
- cache.FailConditionalizations();
- std::string headers;
-
- // Write to the cache (40-49).
- ScopedMockTransaction transaction(kRangeGET_TransactionOK);
- transaction.response_headers = "Content-Length: 10\n"
- "ETag: \"foo\"\n";
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Now verify that the cached data is not used.
- RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
- &headers);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-}
-
-// Tests that restarting a partial request when the cached data cannot be
-// revalidated logs an event.
-TEST(HttpCache, RangeGET_NoValidation_LogsRestart) {
- MockHttpCache cache;
- cache.FailConditionalizations();
-
- // Write to the cache (40-49).
- ScopedMockTransaction transaction(kRangeGET_TransactionOK);
- transaction.response_headers = "Content-Length: 10\n"
- "ETag: \"foo\"\n";
- RunTransactionTest(cache.http_cache(), transaction);
-
- // Now verify that the cached data is not used.
- net::CapturingBoundNetLog log;
- RunTransactionTestWithLog(cache.http_cache(), kRangeGET_TransactionOK,
- log.bound());
-
- EXPECT_TRUE(LogContainsEventType(
- log, net::NetLog::TYPE_HTTP_CACHE_RESTART_PARTIAL_REQUEST));
-}
-
-// Tests that a failure to conditionalize a regular request (no range) with a
-// sparse entry results in a full response.
-TEST(HttpCache, GET_NoConditionalization) {
- MockHttpCache cache;
- cache.FailConditionalizations();
- std::string headers;
-
- // Write to the cache (40-49).
- ScopedMockTransaction transaction(kRangeGET_TransactionOK);
- transaction.response_headers = "Content-Length: 10\n"
- "ETag: \"foo\"\n";
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Now verify that the cached data is not used.
- // Don't ask for a range. The cache will attempt to use the cached data but
- // should discard it as it cannot be validated. A regular request should go
- // to the server and a new entry should be created.
- transaction.request_headers = EXTRA_HEADER;
- transaction.data = "Not a range";
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- EXPECT_EQ(0U, headers.find("HTTP/1.1 200 OK\n"));
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-
- // The last response was saved.
- RunTransactionTest(cache.http_cache(), transaction);
- EXPECT_EQ(3, cache.network_layer()->transaction_count());
- EXPECT_EQ(2, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-}
-
-// Verifies that conditionalization failures when asking for a range that would
-// require the cache to modify the range to ask, result in a network request
-// that matches the user's one.
-TEST(HttpCache, RangeGET_NoConditionalization2) {
- MockHttpCache cache;
- cache.FailConditionalizations();
- std::string headers;
-
- // Write to the cache (40-49).
- ScopedMockTransaction transaction(kRangeGET_TransactionOK);
- transaction.response_headers = "Content-Length: 10\n"
- "ETag: \"foo\"\n";
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Now verify that the cached data is not used.
- // Ask for a range that extends before and after the cached data so that the
- // cache would normally mix data from three sources. After deleting the entry,
- // the response will come from a single network request.
- transaction.request_headers = "Range: bytes = 20-59\r\n" EXTRA_HEADER;
- transaction.data = "rg: 20-29 rg: 30-39 rg: 40-49 rg: 50-59 ";
- transaction.response_headers = kRangeGET_TransactionOK.response_headers;
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 20, 59);
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-
- // The last response was saved.
- RunTransactionTest(cache.http_cache(), transaction);
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(2, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-}
-
-// Tests that we cache partial responses that lack content-length.
-TEST(HttpCache, RangeGET_NoContentLength) {
- MockHttpCache cache;
- std::string headers;
-
- // Attempt to write to the cache (40-49).
- MockTransaction transaction(kRangeGET_TransactionOK);
- AddMockTransaction(&transaction);
- transaction.response_headers = "ETag: \"foo\"\n"
- "Accept-Ranges: bytes\n"
- "Content-Range: bytes 40-49/80\n";
- transaction.handler = NULL;
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Now verify that there's no cached data.
- transaction.handler = &RangeTransactionServer::RangeHandler;
- RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
- &headers);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that we can cache range requests and fetch random blocks from the
-// cache and the network.
-TEST(HttpCache, RangeGET_OK) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
- std::string headers;
-
- // Write to the cache (40-49).
- RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
- &headers);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Read from the cache (40-49).
- RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
- &headers);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Make sure we are done with the previous transaction.
- base::MessageLoop::current()->RunUntilIdle();
-
- // Write to the cache (30-39).
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = "Range: bytes = 30-39\r\n" EXTRA_HEADER;
- transaction.data = "rg: 30-39 ";
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 30, 39);
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(2, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Make sure we are done with the previous transaction.
- base::MessageLoop::current()->RunUntilIdle();
-
- // Write and read from the cache (20-59).
- transaction.request_headers = "Range: bytes = 20-59\r\n" EXTRA_HEADER;
- transaction.data = "rg: 20-29 rg: 30-39 rg: 40-49 rg: 50-59 ";
- net::CapturingBoundNetLog log;
- net::LoadTimingInfo load_timing_info;
- RunTransactionTestWithResponseAndGetTiming(
- cache.http_cache(), transaction, &headers, log.bound(),
- &load_timing_info);
-
- Verify206Response(headers, 20, 59);
- EXPECT_EQ(4, cache.network_layer()->transaction_count());
- EXPECT_EQ(3, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
- TestLoadTimingNetworkRequest(load_timing_info);
-
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-// Tests that we can cache range requests and fetch random blocks from the
-// cache and the network, with synchronous responses.
-TEST(HttpCache, RangeGET_SyncOK) {
- MockHttpCache cache;
-
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.test_mode = TEST_MODE_SYNC_ALL;
- AddMockTransaction(&transaction);
-
- // Write to the cache (40-49).
- std::string headers;
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Read from the cache (40-49).
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Make sure we are done with the previous transaction.
- base::MessageLoop::current()->RunUntilIdle();
-
- // Write to the cache (30-39).
- transaction.request_headers = "Range: bytes = 30-39\r\n" EXTRA_HEADER;
- transaction.data = "rg: 30-39 ";
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 30, 39);
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Make sure we are done with the previous transaction.
- base::MessageLoop::current()->RunUntilIdle();
-
- // Write and read from the cache (20-59).
- transaction.request_headers = "Range: bytes = 20-59\r\n" EXTRA_HEADER;
- transaction.data = "rg: 20-29 rg: 30-39 rg: 40-49 rg: 50-59 ";
- net::CapturingBoundNetLog log;
- net::LoadTimingInfo load_timing_info;
- RunTransactionTestWithResponseAndGetTiming(
- cache.http_cache(), transaction, &headers, log.bound(),
- &load_timing_info);
-
- Verify206Response(headers, 20, 59);
- EXPECT_EQ(4, cache.network_layer()->transaction_count());
- EXPECT_EQ(2, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
- TestLoadTimingNetworkRequest(load_timing_info);
-
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that we don't revalidate an entry unless we are required to do so.
-TEST(HttpCache, RangeGET_Revalidate1) {
- MockHttpCache cache;
- std::string headers;
-
- // Write to the cache (40-49).
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.response_headers =
- "Last-Modified: Sat, 18 Apr 2009 01:10:43 GMT\n"
- "Expires: Wed, 7 Sep 2033 21:46:42 GMT\n" // Should never expire.
- "ETag: \"foo\"\n"
- "Accept-Ranges: bytes\n"
- "Content-Length: 10\n";
- AddMockTransaction(&transaction);
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Read from the cache (40-49).
- net::CapturingBoundNetLog log;
- net::LoadTimingInfo load_timing_info;
- RunTransactionTestWithResponseAndGetTiming(
- cache.http_cache(), transaction, &headers, log.bound(),
- &load_timing_info);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
- TestLoadTimingCachedResponse(load_timing_info);
-
- // Read again forcing the revalidation.
- transaction.load_flags |= net::LOAD_VALIDATE_CACHE;
- RunTransactionTestWithResponseAndGetTiming(
- cache.http_cache(), transaction, &headers, log.bound(),
- &load_timing_info);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
- TestLoadTimingNetworkRequest(load_timing_info);
-
- RemoveMockTransaction(&transaction);
-}
-
-// Checks that we revalidate an entry when the headers say so.
-TEST(HttpCache, RangeGET_Revalidate2) {
- MockHttpCache cache;
- std::string headers;
-
- // Write to the cache (40-49).
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.response_headers =
- "Last-Modified: Sat, 18 Apr 2009 01:10:43 GMT\n"
- "Expires: Sat, 18 Apr 2009 01:10:43 GMT\n" // Expired.
- "ETag: \"foo\"\n"
- "Accept-Ranges: bytes\n"
- "Content-Length: 10\n";
- AddMockTransaction(&transaction);
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Read from the cache (40-49).
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
- Verify206Response(headers, 40, 49);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that we deal with 304s for range requests.
-TEST(HttpCache, RangeGET_304) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
- std::string headers;
-
- // Write to the cache (40-49).
- RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
- &headers);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Read from the cache (40-49).
- RangeTransactionServer handler;
- handler.set_not_modified(true);
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.load_flags |= net::LOAD_VALIDATE_CACHE;
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-// Tests that we deal with 206s when revalidating range requests.
-TEST(HttpCache, RangeGET_ModifiedResult) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
- std::string headers;
-
- // Write to the cache (40-49).
- RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
- &headers);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Attempt to read from the cache (40-49).
- RangeTransactionServer handler;
- handler.set_modified(true);
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.load_flags |= net::LOAD_VALIDATE_CACHE;
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // And the entry should be gone.
- RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
- EXPECT_EQ(3, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-// Tests that when a server returns 206 with a sub-range of the requested range,
-// and there is nothing stored in the cache, the returned response is passed to
-// the caller as is. In this context, a subrange means a response that starts
-// with the same byte that was requested, but that is not the whole range that
-// was requested.
-TEST(HttpCache, RangeGET_206ReturnsSubrangeRange_NoCachedContent) {
- MockHttpCache cache;
- std::string headers;
-
- // Request a large range (40-59). The server sends 40-49.
- ScopedMockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = "Range: bytes = 40-59\r\n" EXTRA_HEADER;
- transaction.response_headers =
- "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
- "ETag: \"foo\"\n"
- "Accept-Ranges: bytes\n"
- "Content-Length: 10\n"
- "Content-Range: bytes 40-49/80\n";
- transaction.handler = nullptr;
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-}
-
-// Tests that when a server returns 206 with a sub-range of the requested range,
-// and there was an entry stored in the cache, the cache gets out of the way.
-TEST(HttpCache, RangeGET_206ReturnsSubrangeRange_CachedContent) {
- MockHttpCache cache;
- std::string headers;
-
- // Write to the cache (70-79).
- ScopedMockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = "Range: bytes = 70-79\r\n" EXTRA_HEADER;
- transaction.data = "rg: 70-79 ";
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
- Verify206Response(headers, 70, 79);
-
- // Request a large range (40-79). The cache will ask the server for 40-59.
- // The server returns 40-49. The cache should consider the server confused and
- // abort caching, restarting the request without caching.
- transaction.request_headers = "Range: bytes = 40-79\r\n" EXTRA_HEADER;
- transaction.response_headers =
- "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
- "ETag: \"foo\"\n"
- "Accept-Ranges: bytes\n"
- "Content-Length: 10\n"
- "Content-Range: bytes 40-49/80\n";
- transaction.handler = nullptr;
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- // Two new network requests were issued, one from the cache and another after
- // deleting the entry.
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(3, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // The entry was deleted.
- RunTransactionTest(cache.http_cache(), transaction);
- EXPECT_EQ(4, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-}
-
-// Tests that when a server returns 206 with a sub-range of the requested range,
-// and there was an entry stored in the cache, the cache gets out of the way,
-// when the caller is not using ranges.
-TEST(HttpCache, GET_206ReturnsSubrangeRange_CachedContent) {
- MockHttpCache cache;
- std::string headers;
-
- // Write to the cache (70-79).
- ScopedMockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = "Range: bytes = 70-79\r\n" EXTRA_HEADER;
- transaction.data = "rg: 70-79 ";
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
- Verify206Response(headers, 70, 79);
-
- // Don't ask for a range. The cache will ask the server for 0-69.
- // The server returns 40-49. The cache should consider the server confused and
- // abort caching, restarting the request.
- // The second network request should not be a byte range request so the server
- // should return 200 + "Not a range"
- transaction.request_headers = "X-Return-Default-Range:\r\n" EXTRA_HEADER;
- transaction.data = "Not a range";
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- EXPECT_EQ(0U, headers.find("HTTP/1.1 200 OK\n"));
- EXPECT_EQ(3, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // The entry was deleted.
- RunTransactionTest(cache.http_cache(), transaction);
- EXPECT_EQ(4, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-}
-
-// Tests that when a server returns 206 with a random range and there is
-// nothing stored in the cache, the returned response is passed to the caller
-// as is. In this context, a WrongRange means that the returned range may or may
-// not have any relationship with the requested range (may or may not be
-// contained). The important part is that the first byte doesn't match the first
-// requested byte.
-TEST(HttpCache, RangeGET_206ReturnsWrongRange_NoCachedContent) {
- MockHttpCache cache;
- std::string headers;
-
- // Request a large range (30-59). The server sends (40-49).
- ScopedMockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = "Range: bytes = 30-59\r\n" EXTRA_HEADER;
- transaction.response_headers =
- "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
- "ETag: \"foo\"\n"
- "Accept-Ranges: bytes\n"
- "Content-Length: 10\n"
- "Content-Range: bytes 40-49/80\n";
- transaction.handler = nullptr;
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // The entry was deleted.
- RunTransactionTest(cache.http_cache(), transaction);
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-}
-
-// Tests that when a server returns 206 with a random range and there is
-// an entry stored in the cache, the cache gets out of the way.
-TEST(HttpCache, RangeGET_206ReturnsWrongRange_CachedContent) {
- MockHttpCache cache;
- std::string headers;
-
- // Write to the cache (70-79).
- ScopedMockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = "Range: bytes = 70-79\r\n" EXTRA_HEADER;
- transaction.data = "rg: 70-79 ";
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
- Verify206Response(headers, 70, 79);
-
- // Request a large range (30-79). The cache will ask the server for 30-69.
- // The server returns 40-49. The cache should consider the server confused and
- // abort caching, returning the weird range to the caller.
- transaction.request_headers = "Range: bytes = 30-79\r\n" EXTRA_HEADER;
- transaction.response_headers =
- "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
- "ETag: \"foo\"\n"
- "Accept-Ranges: bytes\n"
- "Content-Length: 10\n"
- "Content-Range: bytes 40-49/80\n";
- transaction.handler = nullptr;
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(3, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // The entry was deleted.
- RunTransactionTest(cache.http_cache(), transaction);
- EXPECT_EQ(4, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-}
-
-// Tests that when a caller asks for a range beyond EOF, with an empty cache,
-// the response matches the one provided by the server.
-TEST(HttpCache, RangeGET_206ReturnsSmallerFile_NoCachedContent) {
- MockHttpCache cache;
- std::string headers;
-
- // Request a large range (70-99). The server sends 70-79.
- ScopedMockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = "Range: bytes = 70-99\r\n" EXTRA_HEADER;
- transaction.data = "rg: 70-79 ";
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 70, 79);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
- EXPECT_EQ(1, cache.disk_cache()->open_count());
-}
-
-// Tests that when a caller asks for a range beyond EOF, with a cached entry,
-// the cache automatically fixes the request.
-TEST(HttpCache, RangeGET_206ReturnsSmallerFile_CachedContent) {
- MockHttpCache cache;
- std::string headers;
-
- // Write to the cache (40-49).
- ScopedMockTransaction transaction(kRangeGET_TransactionOK);
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- // Request a large range (70-99). The server sends 70-79.
- transaction.request_headers = "Range: bytes = 70-99\r\n" EXTRA_HEADER;
- transaction.data = "rg: 70-79 ";
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 70, 79);
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // The entry was not deleted (the range was automatically fixed).
- RunTransactionTest(cache.http_cache(), transaction);
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(2, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-}
-
-// Tests that when a caller asks for a not-satisfiable range, the server's
-// response is forwarded to the caller.
-TEST(HttpCache, RangeGET_416_NoCachedContent) {
- MockHttpCache cache;
- std::string headers;
-
- // Request a range beyond EOF (80-99).
- ScopedMockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = "Range: bytes = 80-99\r\n" EXTRA_HEADER;
- transaction.data = "";
- transaction.status = "HTTP/1.1 416 Requested Range Not Satisfiable";
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- EXPECT_EQ(0U, headers.find(transaction.status));
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // The entry was deleted.
- RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-}
-
-// Tests that we cache 301s for range requests.
-TEST(HttpCache, RangeGET_301) {
- MockHttpCache cache;
- ScopedMockTransaction transaction(kRangeGET_TransactionOK);
- transaction.status = "HTTP/1.1 301 Moved Permanently";
- transaction.response_headers = "Location: http://www.bar.com/\n";
- transaction.data = "";
- transaction.handler = NULL;
-
- // Write to the cache.
- RunTransactionTest(cache.http_cache(), transaction);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Read from the cache.
- RunTransactionTest(cache.http_cache(), transaction);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-}
-
-// Tests that we can cache range requests when the start or end is unknown.
-// We start with one suffix request, followed by a request from a given point.
-TEST(HttpCache, UnknownRangeGET_1) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
- std::string headers;
-
- // Write to the cache (70-79).
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = "Range: bytes = -10\r\n" EXTRA_HEADER;
- transaction.data = "rg: 70-79 ";
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 70, 79);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Make sure we are done with the previous transaction.
- base::MessageLoop::current()->RunUntilIdle();
-
- // Write and read from the cache (60-79).
- transaction.request_headers = "Range: bytes = 60-\r\n" EXTRA_HEADER;
- transaction.data = "rg: 60-69 rg: 70-79 ";
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 60, 79);
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-// Tests that we can cache range requests when the start or end is unknown.
-// We start with one request from a given point, followed by a suffix request.
-// We'll also verify that synchronous cache responses work as intended.
-TEST(HttpCache, UnknownRangeGET_2) {
- MockHttpCache cache;
- std::string headers;
-
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.test_mode = TEST_MODE_SYNC_CACHE_START |
- TEST_MODE_SYNC_CACHE_READ |
- TEST_MODE_SYNC_CACHE_WRITE;
- AddMockTransaction(&transaction);
-
- // Write to the cache (70-79).
- transaction.request_headers = "Range: bytes = 70-\r\n" EXTRA_HEADER;
- transaction.data = "rg: 70-79 ";
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 70, 79);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Make sure we are done with the previous transaction.
- base::MessageLoop::current()->RunUntilIdle();
-
- // Write and read from the cache (60-79).
- transaction.request_headers = "Range: bytes = -20\r\n" EXTRA_HEADER;
- transaction.data = "rg: 60-69 rg: 70-79 ";
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 60, 79);
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that receiving Not Modified when asking for an open range doesn't mess
-// up things.
-TEST(HttpCache, UnknownRangeGET_304) {
- MockHttpCache cache;
- std::string headers;
-
- MockTransaction transaction(kRangeGET_TransactionOK);
- AddMockTransaction(&transaction);
-
- RangeTransactionServer handler;
- handler.set_not_modified(true);
-
- // Ask for the end of the file, without knowing the length.
- transaction.request_headers = "Range: bytes = 70-\r\n" EXTRA_HEADER;
- transaction.data = "";
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- // We just bypass the cache.
- EXPECT_EQ(0U, headers.find("HTTP/1.1 304 Not Modified\n"));
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- RunTransactionTest(cache.http_cache(), transaction);
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that we can handle non-range requests when we have cached a range.
-TEST(HttpCache, GET_Previous206) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
- std::string headers;
- net::CapturingBoundNetLog log;
- net::LoadTimingInfo load_timing_info;
-
- // Write to the cache (40-49).
- RunTransactionTestWithResponseAndGetTiming(
- cache.http_cache(), kRangeGET_TransactionOK, &headers, log.bound(),
- &load_timing_info);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
- TestLoadTimingNetworkRequest(load_timing_info);
-
- // Write and read from the cache (0-79), when not asked for a range.
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = EXTRA_HEADER;
- transaction.data = kFullRangeData;
- RunTransactionTestWithResponseAndGetTiming(
- cache.http_cache(), transaction, &headers, log.bound(),
- &load_timing_info);
-
- EXPECT_EQ(0U, headers.find("HTTP/1.1 200 OK\n"));
- EXPECT_EQ(3, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
- TestLoadTimingNetworkRequest(load_timing_info);
-
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-// Tests that we can handle non-range requests when we have cached the first
-// part of the object and the server replies with 304 (Not Modified).
-TEST(HttpCache, GET_Previous206_NotModified) {
- MockHttpCache cache;
-
- MockTransaction transaction(kRangeGET_TransactionOK);
- AddMockTransaction(&transaction);
- std::string headers;
- net::CapturingBoundNetLog log;
- net::LoadTimingInfo load_timing_info;
-
- // Write to the cache (0-9).
- transaction.request_headers = "Range: bytes = 0-9\r\n" EXTRA_HEADER;
- transaction.data = "rg: 00-09 ";
- RunTransactionTestWithResponseAndGetTiming(
- cache.http_cache(), transaction, &headers, log.bound(),
- &load_timing_info);
- Verify206Response(headers, 0, 9);
- TestLoadTimingNetworkRequest(load_timing_info);
-
- // Write to the cache (70-79).
- transaction.request_headers = "Range: bytes = 70-79\r\n" EXTRA_HEADER;
- transaction.data = "rg: 70-79 ";
- RunTransactionTestWithResponseAndGetTiming(
- cache.http_cache(), transaction, &headers, log.bound(),
- &load_timing_info);
- Verify206Response(headers, 70, 79);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
- TestLoadTimingNetworkRequest(load_timing_info);
-
- // Read from the cache (0-9), write and read from cache (10 - 79).
- transaction.load_flags |= net::LOAD_VALIDATE_CACHE;
- transaction.request_headers = "Foo: bar\r\n" EXTRA_HEADER;
- transaction.data = kFullRangeData;
- RunTransactionTestWithResponseAndGetTiming(
- cache.http_cache(), transaction, &headers, log.bound(),
- &load_timing_info);
-
- EXPECT_EQ(0U, headers.find("HTTP/1.1 200 OK\n"));
- EXPECT_EQ(4, cache.network_layer()->transaction_count());
- EXPECT_EQ(2, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
- TestLoadTimingNetworkRequest(load_timing_info);
-
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that we can handle a regular request to a sparse entry, that results in
-// new content provided by the server (206).
-TEST(HttpCache, GET_Previous206_NewContent) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
- std::string headers;
-
- // Write to the cache (0-9).
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = "Range: bytes = 0-9\r\n" EXTRA_HEADER;
- transaction.data = "rg: 00-09 ";
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 0, 9);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Now we'll issue a request without any range that should result first in a
- // 206 (when revalidating), and then in a weird standard answer: the test
- // server will not modify the response so we'll get the default range... a
- // real server will answer with 200.
- MockTransaction transaction2(kRangeGET_TransactionOK);
- transaction2.request_headers = EXTRA_HEADER;
- transaction2.load_flags |= net::LOAD_VALIDATE_CACHE;
- transaction2.data = "Not a range";
- RangeTransactionServer handler;
- handler.set_modified(true);
- net::CapturingBoundNetLog log;
- net::LoadTimingInfo load_timing_info;
- RunTransactionTestWithResponseAndGetTiming(
- cache.http_cache(), transaction2, &headers, log.bound(),
- &load_timing_info);
-
- EXPECT_EQ(0U, headers.find("HTTP/1.1 200 OK\n"));
- EXPECT_EQ(3, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
- TestLoadTimingNetworkRequest(load_timing_info);
-
- // Verify that the previous request deleted the entry.
- RunTransactionTest(cache.http_cache(), transaction);
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that we can handle cached 206 responses that are not sparse.
-TEST(HttpCache, GET_Previous206_NotSparse) {
- MockHttpCache cache;
-
- // Create a disk cache entry that stores 206 headers while not being sparse.
- disk_cache::Entry* entry;
- ASSERT_TRUE(cache.CreateBackendEntry(kSimpleGET_Transaction.url, &entry,
- NULL));
-
- std::string raw_headers(kRangeGET_TransactionOK.status);
- raw_headers.append("\n");
- raw_headers.append(kRangeGET_TransactionOK.response_headers);
- raw_headers = net::HttpUtil::AssembleRawHeaders(raw_headers.data(),
- raw_headers.size());
-
- net::HttpResponseInfo response;
- response.headers = new net::HttpResponseHeaders(raw_headers);
- EXPECT_TRUE(MockHttpCache::WriteResponseInfo(entry, &response, true, false));
-
- scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(500));
- int len = static_cast<int>(base::strlcpy(buf->data(),
- kRangeGET_TransactionOK.data, 500));
- net::TestCompletionCallback cb;
- int rv = entry->WriteData(1, 0, buf.get(), len, cb.callback(), true);
- EXPECT_EQ(len, cb.GetResult(rv));
- entry->Close();
-
- // Now see that we don't use the stored entry.
- std::string headers;
- net::CapturingBoundNetLog log;
- net::LoadTimingInfo load_timing_info;
- RunTransactionTestWithResponseAndGetTiming(
- cache.http_cache(), kSimpleGET_Transaction, &headers, log.bound(),
- &load_timing_info);
-
- // We are expecting a 200.
- std::string expected_headers(kSimpleGET_Transaction.status);
- expected_headers.append("\n");
- expected_headers.append(kSimpleGET_Transaction.response_headers);
- EXPECT_EQ(expected_headers, headers);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
- TestLoadTimingNetworkRequest(load_timing_info);
-}
-
-// Tests that we can handle cached 206 responses that are not sparse. This time
-// we issue a range request and expect to receive a range.
-TEST(HttpCache, RangeGET_Previous206_NotSparse_2) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
-
- // Create a disk cache entry that stores 206 headers while not being sparse.
- disk_cache::Entry* entry;
- ASSERT_TRUE(cache.CreateBackendEntry(kRangeGET_TransactionOK.url, &entry,
- NULL));
-
- std::string raw_headers(kRangeGET_TransactionOK.status);
- raw_headers.append("\n");
- raw_headers.append(kRangeGET_TransactionOK.response_headers);
- raw_headers = net::HttpUtil::AssembleRawHeaders(raw_headers.data(),
- raw_headers.size());
-
- net::HttpResponseInfo response;
- response.headers = new net::HttpResponseHeaders(raw_headers);
- EXPECT_TRUE(MockHttpCache::WriteResponseInfo(entry, &response, true, false));
-
- scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(500));
- int len = static_cast<int>(base::strlcpy(buf->data(),
- kRangeGET_TransactionOK.data, 500));
- net::TestCompletionCallback cb;
- int rv = entry->WriteData(1, 0, buf.get(), len, cb.callback(), true);
- EXPECT_EQ(len, cb.GetResult(rv));
- entry->Close();
-
- // Now see that we don't use the stored entry.
- std::string headers;
- RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
- &headers);
-
- // We are expecting a 206.
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-// Tests that we can handle cached 206 responses that can't be validated.
-TEST(HttpCache, GET_Previous206_NotValidation) {
- MockHttpCache cache;
-
- // Create a disk cache entry that stores 206 headers.
- disk_cache::Entry* entry;
- ASSERT_TRUE(cache.CreateBackendEntry(kSimpleGET_Transaction.url, &entry,
- NULL));
-
- // Make sure that the headers cannot be validated with the server.
- std::string raw_headers(kRangeGET_TransactionOK.status);
- raw_headers.append("\n");
- raw_headers.append("Content-Length: 80\n");
- raw_headers = net::HttpUtil::AssembleRawHeaders(raw_headers.data(),
- raw_headers.size());
-
- net::HttpResponseInfo response;
- response.headers = new net::HttpResponseHeaders(raw_headers);
- EXPECT_TRUE(MockHttpCache::WriteResponseInfo(entry, &response, true, false));
-
- scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(500));
- int len = static_cast<int>(base::strlcpy(buf->data(),
- kRangeGET_TransactionOK.data, 500));
- net::TestCompletionCallback cb;
- int rv = entry->WriteData(1, 0, buf.get(), len, cb.callback(), true);
- EXPECT_EQ(len, cb.GetResult(rv));
- entry->Close();
-
- // Now see that we don't use the stored entry.
- std::string headers;
- RunTransactionTestWithResponse(cache.http_cache(), kSimpleGET_Transaction,
- &headers);
-
- // We are expecting a 200.
- std::string expected_headers(kSimpleGET_Transaction.status);
- expected_headers.append("\n");
- expected_headers.append(kSimpleGET_Transaction.response_headers);
- EXPECT_EQ(expected_headers, headers);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-}
-
-// Tests that we can handle range requests with cached 200 responses.
-TEST(HttpCache, RangeGET_Previous200) {
- MockHttpCache cache;
-
- // Store the whole thing with status 200.
- MockTransaction transaction(kTypicalGET_Transaction);
- transaction.url = kRangeGET_TransactionOK.url;
- transaction.data = kFullRangeData;
- AddMockTransaction(&transaction);
- RunTransactionTest(cache.http_cache(), transaction);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- RemoveMockTransaction(&transaction);
- AddMockTransaction(&kRangeGET_TransactionOK);
-
- // Now see that we use the stored entry.
- std::string headers;
- MockTransaction transaction2(kRangeGET_TransactionOK);
- RangeTransactionServer handler;
- handler.set_not_modified(true);
- RunTransactionTestWithResponse(cache.http_cache(), transaction2, &headers);
-
- // We are expecting a 206.
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // The last transaction has finished so make sure the entry is deactivated.
- base::MessageLoop::current()->RunUntilIdle();
-
- // Make a request for an invalid range.
- MockTransaction transaction3(kRangeGET_TransactionOK);
- transaction3.request_headers = "Range: bytes = 80-90\r\n" EXTRA_HEADER;
- transaction3.data = transaction.data;
- transaction3.load_flags = net::LOAD_PREFERRING_CACHE;
- RunTransactionTestWithResponse(cache.http_cache(), transaction3, &headers);
- EXPECT_EQ(2, cache.disk_cache()->open_count());
- EXPECT_EQ(0U, headers.find("HTTP/1.1 200 "));
- EXPECT_EQ(std::string::npos, headers.find("Content-Range:"));
- EXPECT_EQ(std::string::npos, headers.find("Content-Length: 80"));
-
- // Make sure the entry is deactivated.
- base::MessageLoop::current()->RunUntilIdle();
-
- // Even though the request was invalid, we should have the entry.
- RunTransactionTest(cache.http_cache(), transaction2);
- EXPECT_EQ(3, cache.disk_cache()->open_count());
-
- // Make sure the entry is deactivated.
- base::MessageLoop::current()->RunUntilIdle();
-
- // Now we should receive a range from the server and drop the stored entry.
- handler.set_not_modified(false);
- transaction2.request_headers = kRangeGET_TransactionOK.request_headers;
- RunTransactionTestWithResponse(cache.http_cache(), transaction2, &headers);
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(4, cache.network_layer()->transaction_count());
- EXPECT_EQ(4, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- RunTransactionTest(cache.http_cache(), transaction2);
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-// Tests that we can handle a 200 response when dealing with sparse entries.
-TEST(HttpCache, RangeRequestResultsIn200) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
- std::string headers;
-
- // Write to the cache (70-79).
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = "Range: bytes = -10\r\n" EXTRA_HEADER;
- transaction.data = "rg: 70-79 ";
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 70, 79);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Now we'll issue a request that results in a plain 200 response, but to
- // the to the same URL that we used to store sparse data, and making sure
- // that we ask for a range.
- RemoveMockTransaction(&kRangeGET_TransactionOK);
- MockTransaction transaction2(kSimpleGET_Transaction);
- transaction2.url = kRangeGET_TransactionOK.url;
- transaction2.request_headers = kRangeGET_TransactionOK.request_headers;
- AddMockTransaction(&transaction2);
-
- RunTransactionTestWithResponse(cache.http_cache(), transaction2, &headers);
-
- std::string expected_headers(kSimpleGET_Transaction.status);
- expected_headers.append("\n");
- expected_headers.append(kSimpleGET_Transaction.response_headers);
- EXPECT_EQ(expected_headers, headers);
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- RemoveMockTransaction(&transaction2);
-}
-
-// Tests that a range request that falls outside of the size that we know about
-// only deletes the entry if the resource has indeed changed.
-TEST(HttpCache, RangeGET_MoreThanCurrentSize) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
- std::string headers;
-
- // Write to the cache (40-49).
- RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
- &headers);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // A weird request should not delete this entry. Ask for bytes 120-.
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = "Range: bytes = 120-\r\n" EXTRA_HEADER;
- transaction.data = "";
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- EXPECT_EQ(0U, headers.find("HTTP/1.1 416 "));
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
- EXPECT_EQ(2, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-// Tests that we don't delete a sparse entry when we cancel a request.
-TEST(HttpCache, RangeGET_Cancel) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
-
- MockHttpRequest request(kRangeGET_TransactionOK);
-
- 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());
- if (rv == net::ERR_IO_PENDING)
- rv = c->callback.WaitForResult();
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Make sure that the entry has some data stored.
- scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(10));
- rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
- if (rv == net::ERR_IO_PENDING)
- rv = c->callback.WaitForResult();
- EXPECT_EQ(buf->size(), rv);
-
- // Destroy the transaction.
- delete c;
-
- // Verify that the entry has not been deleted.
- disk_cache::Entry* entry;
- ASSERT_TRUE(cache.OpenBackendEntry(kRangeGET_TransactionOK.url, &entry));
- entry->Close();
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-// Tests that we don't delete a sparse entry when we start a new request after
-// cancelling the previous one.
-TEST(HttpCache, RangeGET_Cancel2) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
-
- RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
- MockHttpRequest request(kRangeGET_TransactionOK);
- request.load_flags |= net::LOAD_VALIDATE_CACHE;
-
- 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());
- if (rv == net::ERR_IO_PENDING)
- rv = c->callback.WaitForResult();
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Make sure that we revalidate the entry and read from the cache (a single
- // read will return while waiting for the network).
- scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(5));
- rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
- EXPECT_EQ(5, c->callback.GetResult(rv));
- rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
- EXPECT_EQ(net::ERR_IO_PENDING, rv);
-
- // Destroy the transaction before completing the read.
- delete c;
-
- // We have the read and the delete (OnProcessPendingQueue) waiting on the
- // message loop. This means that a new transaction will just reuse the same
- // active entry (no open or create).
-
- RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-// A slight variation of the previous test, this time we cancel two requests in
-// a row, making sure that the second is waiting for the entry to be ready.
-TEST(HttpCache, RangeGET_Cancel3) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
-
- RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
- MockHttpRequest request(kRangeGET_TransactionOK);
- request.load_flags |= net::LOAD_VALIDATE_CACHE;
-
- 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();
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Make sure that we revalidate the entry and read from the cache (a single
- // read will return while waiting for the network).
- scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(5));
- rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
- EXPECT_EQ(5, c->callback.GetResult(rv));
- rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
- EXPECT_EQ(net::ERR_IO_PENDING, rv);
-
- // Destroy the transaction before completing the read.
- delete c;
-
- // We have the read and the delete (OnProcessPendingQueue) waiting on the
- // message loop. This means that a new transaction will just reuse the same
- // active entry (no open or create).
-
- c = new Context();
- 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);
-
- MockDiskEntry::IgnoreCallbacks(true);
- base::MessageLoop::current()->RunUntilIdle();
- MockDiskEntry::IgnoreCallbacks(false);
-
- // The new transaction is waiting for the query range callback.
- delete c;
-
- // And we should not crash when the callback is delivered.
- base::MessageLoop::current()->RunUntilIdle();
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-// Tests that an invalid range response results in no cached entry.
-TEST(HttpCache, RangeGET_InvalidResponse1) {
- MockHttpCache cache;
- std::string headers;
-
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.handler = NULL;
- transaction.response_headers = "Content-Range: bytes 40-49/45\n"
- "Content-Length: 10\n";
- AddMockTransaction(&transaction);
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- std::string expected(transaction.status);
- expected.append("\n");
- expected.append(transaction.response_headers);
- EXPECT_EQ(expected, headers);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Verify that we don't have a cached entry.
- disk_cache::Entry* entry;
- EXPECT_FALSE(cache.OpenBackendEntry(kRangeGET_TransactionOK.url, &entry));
-
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-// Tests that we reject a range that doesn't match the content-length.
-TEST(HttpCache, RangeGET_InvalidResponse2) {
- MockHttpCache cache;
- std::string headers;
-
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.handler = NULL;
- transaction.response_headers = "Content-Range: bytes 40-49/80\n"
- "Content-Length: 20\n";
- AddMockTransaction(&transaction);
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- std::string expected(transaction.status);
- expected.append("\n");
- expected.append(transaction.response_headers);
- EXPECT_EQ(expected, headers);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Verify that we don't have a cached entry.
- disk_cache::Entry* entry;
- EXPECT_FALSE(cache.OpenBackendEntry(kRangeGET_TransactionOK.url, &entry));
-
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-// Tests that if a server tells us conflicting information about a resource we
-// drop the entry.
-TEST(HttpCache, RangeGET_InvalidResponse3) {
- MockHttpCache cache;
- std::string headers;
-
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.handler = NULL;
- transaction.request_headers = "Range: bytes = 50-59\r\n" EXTRA_HEADER;
- std::string response_headers(transaction.response_headers);
- response_headers.append("Content-Range: bytes 50-59/160\n");
- transaction.response_headers = response_headers.c_str();
- AddMockTransaction(&transaction);
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 50, 59);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- RemoveMockTransaction(&transaction);
- AddMockTransaction(&kRangeGET_TransactionOK);
-
- // This transaction will report a resource size of 80 bytes, and we think it's
- // 160 so we should ignore the response.
- RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
- &headers);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Verify that the entry is gone.
- RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-// Tests that we handle large range values properly.
-TEST(HttpCache, RangeGET_LargeValues) {
- // We need a real sparse cache for this test.
- MockHttpCache cache(net::HttpCache::DefaultBackend::InMemory(1024 * 1024));
- std::string headers;
-
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.handler = NULL;
- transaction.request_headers = "Range: bytes = 4294967288-4294967297\r\n"
- EXTRA_HEADER;
- transaction.response_headers =
- "ETag: \"foo\"\n"
- "Content-Range: bytes 4294967288-4294967297/4294967299\n"
- "Content-Length: 10\n";
- AddMockTransaction(&transaction);
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- std::string expected(transaction.status);
- expected.append("\n");
- expected.append(transaction.response_headers);
- EXPECT_EQ(expected, headers);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
-
- // Verify that we have a cached entry.
- disk_cache::Entry* en;
- ASSERT_TRUE(cache.OpenBackendEntry(kRangeGET_TransactionOK.url, &en));
- en->Close();
-
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-// Tests that we don't crash with a range request if the disk cache was not
-// initialized properly.
-TEST(HttpCache, RangeGET_NoDiskCache) {
- MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
- factory->set_fail(true);
- factory->FinishCreation(); // We'll complete synchronously.
- MockHttpCache cache(factory);
-
- AddMockTransaction(&kRangeGET_TransactionOK);
-
- RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
-
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-// Tests that we handle byte range requests that skip the cache.
-TEST(HttpCache, RangeHEAD) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
-
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = "Range: bytes = -10\r\n" EXTRA_HEADER;
- transaction.method = "HEAD";
- transaction.data = "rg: 70-79 ";
-
- std::string headers;
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- Verify206Response(headers, 70, 79);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(0, cache.disk_cache()->create_count());
-
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-// Tests that we don't crash when after reading from the cache we issue a
-// request for the next range and the server gives us a 200 synchronously.
-TEST(HttpCache, RangeGET_FastFlakyServer) {
- MockHttpCache cache;
-
- ScopedMockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = "Range: bytes = 40-\r\n" EXTRA_HEADER;
- transaction.test_mode = TEST_MODE_SYNC_NET_START;
- transaction.load_flags |= net::LOAD_VALIDATE_CACHE;
-
- // Write to the cache.
- RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
-
- // And now read from the cache and the network.
- RangeTransactionServer handler;
- handler.set_bad_200(true);
- transaction.data = "Not a range";
- net::CapturingBoundNetLog log;
- RunTransactionTestWithLog(cache.http_cache(), transaction, log.bound());
-
- EXPECT_EQ(3, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
- EXPECT_TRUE(LogContainsEventType(
- log, net::NetLog::TYPE_HTTP_CACHE_RE_SEND_PARTIAL_REQUEST));
-}
-
-// Tests that when the server gives us less data than expected, we don't keep
-// asking for more data.
-TEST(HttpCache, RangeGET_FastFlakyServer2) {
- MockHttpCache cache;
-
- // First, check with an empty cache (WRITE mode).
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = "Range: bytes = 40-49\r\n" EXTRA_HEADER;
- transaction.data = "rg: 40-"; // Less than expected.
- transaction.handler = NULL;
- std::string headers(transaction.response_headers);
- headers.append("Content-Range: bytes 40-49/80\n");
- transaction.response_headers = headers.c_str();
-
- AddMockTransaction(&transaction);
-
- // Write to the cache.
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Now verify that even in READ_WRITE mode, we forward the bad response to
- // the caller.
- transaction.request_headers = "Range: bytes = 60-69\r\n" EXTRA_HEADER;
- transaction.data = "rg: 60-"; // Less than expected.
- headers = kRangeGET_TransactionOK.response_headers;
- headers.append("Content-Range: bytes 60-69/80\n");
- transaction.response_headers = headers.c_str();
-
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- RemoveMockTransaction(&transaction);
-}
-
-#if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
-// This test hits a NOTREACHED so it is a release mode only test.
-TEST(HttpCache, RangeGET_OK_LoadOnlyFromCache) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
-
- // Write to the cache (40-49).
- RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Force this transaction to read from the cache.
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
-
- 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());
- if (rv == net::ERR_IO_PENDING)
- rv = callback.WaitForResult();
- ASSERT_EQ(net::ERR_CACHE_MISS, rv);
-
- trans.reset();
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-#endif
-
-// Tests the handling of the "truncation" flag.
-TEST(HttpCache, WriteResponseInfo_Truncated) {
- MockHttpCache cache;
- disk_cache::Entry* entry;
- ASSERT_TRUE(cache.CreateBackendEntry("http://www.google.com", &entry,
- NULL));
-
- std::string headers("HTTP/1.1 200 OK");
- headers = net::HttpUtil::AssembleRawHeaders(headers.data(), headers.size());
- net::HttpResponseInfo response;
- response.headers = new net::HttpResponseHeaders(headers);
-
- // Set the last argument for this to be an incomplete request.
- EXPECT_TRUE(MockHttpCache::WriteResponseInfo(entry, &response, true, true));
- bool truncated = false;
- EXPECT_TRUE(MockHttpCache::ReadResponseInfo(entry, &response, &truncated));
- EXPECT_TRUE(truncated);
-
- // And now test the opposite case.
- EXPECT_TRUE(MockHttpCache::WriteResponseInfo(entry, &response, true, false));
- truncated = true;
- EXPECT_TRUE(MockHttpCache::ReadResponseInfo(entry, &response, &truncated));
- EXPECT_FALSE(truncated);
- entry->Close();
-}
-
-// Tests basic pickling/unpickling of HttpResponseInfo.
-TEST(HttpCache, PersistHttpResponseInfo) {
- // Set some fields (add more if needed.)
- net::HttpResponseInfo response1;
- response1.was_cached = false;
- response1.socket_address = net::HostPortPair("1.2.3.4", 80);
- response1.headers = new net::HttpResponseHeaders("HTTP/1.1 200 OK");
-
- // Pickle.
- Pickle pickle;
- response1.Persist(&pickle, false, false);
-
- // Unpickle.
- net::HttpResponseInfo response2;
- bool response_truncated;
- EXPECT_TRUE(response2.InitFromPickle(pickle, &response_truncated));
- EXPECT_FALSE(response_truncated);
-
- // Verify fields.
- EXPECT_TRUE(response2.was_cached); // InitFromPickle sets this flag.
- EXPECT_EQ("1.2.3.4", response2.socket_address.host());
- EXPECT_EQ(80, response2.socket_address.port());
- EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
-}
-
-// Tests that we delete an entry when the request is cancelled before starting
-// to read from the network.
-TEST(HttpCache, DoomOnDestruction) {
- MockHttpCache cache;
-
- MockHttpRequest request(kSimpleGET_Transaction);
-
- 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());
- if (rv == net::ERR_IO_PENDING)
- c->result = c->callback.WaitForResult();
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Destroy the transaction. We only have the headers so we should delete this
- // entry.
- delete c;
-
- RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-}
-
-// Tests that we delete an entry when the request is cancelled if the response
-// does not have content-length and strong validators.
-TEST(HttpCache, DoomOnDestruction2) {
- MockHttpCache cache;
-
- MockHttpRequest request(kSimpleGET_Transaction);
-
- 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());
- if (rv == net::ERR_IO_PENDING)
- rv = c->callback.WaitForResult();
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Make sure that the entry has some data stored.
- scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(10));
- rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
- if (rv == net::ERR_IO_PENDING)
- rv = c->callback.WaitForResult();
- EXPECT_EQ(buf->size(), rv);
-
- // Destroy the transaction.
- delete c;
-
- RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-}
-
-// Tests that we delete an entry when the request is cancelled if the response
-// has an "Accept-Ranges: none" header.
-TEST(HttpCache, DoomOnDestruction3) {
- MockHttpCache cache;
-
- MockTransaction transaction(kSimpleGET_Transaction);
- transaction.response_headers =
- "Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
- "Content-Length: 22\n"
- "Accept-Ranges: none\n"
- "Etag: \"foopy\"\n";
- AddMockTransaction(&transaction);
- MockHttpRequest request(transaction);
-
- 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());
- if (rv == net::ERR_IO_PENDING)
- rv = c->callback.WaitForResult();
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Make sure that the entry has some data stored.
- scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(10));
- rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
- if (rv == net::ERR_IO_PENDING)
- rv = c->callback.WaitForResult();
- EXPECT_EQ(buf->size(), rv);
-
- // Destroy the transaction.
- delete c;
-
- RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that we mark an entry as incomplete when the request is cancelled.
-TEST(HttpCache, SetTruncatedFlag) {
- MockHttpCache cache;
-
- MockTransaction transaction(kSimpleGET_Transaction);
- transaction.response_headers =
- "Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
- "Content-Length: 22\n"
- "Etag: \"foopy\"\n";
- AddMockTransaction(&transaction);
- MockHttpRequest request(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());
- if (rv == net::ERR_IO_PENDING)
- rv = c->callback.WaitForResult();
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Make sure that the entry has some data stored.
- scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(10));
- rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
- if (rv == net::ERR_IO_PENDING)
- rv = c->callback.WaitForResult();
- EXPECT_EQ(buf->size(), rv);
-
- // We want to cancel the request when the transaction is busy.
- rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
- EXPECT_EQ(net::ERR_IO_PENDING, rv);
- EXPECT_FALSE(c->callback.have_result());
-
- MockHttpCache::SetTestMode(TEST_MODE_SYNC_ALL);
-
- // Destroy the transaction.
- c->trans.reset();
- MockHttpCache::SetTestMode(0);
-
-
- // Make sure that we don't invoke the callback. We may have an issue if the
- // UrlRequestJob is killed directly (without cancelling the UrlRequest) so we
- // could end up with the transaction being deleted twice if we send any
- // notification from the transaction destructor (see http://crbug.com/31723).
- EXPECT_FALSE(c->callback.have_result());
-
- // Verify that the entry is marked as incomplete.
- disk_cache::Entry* entry;
- ASSERT_TRUE(cache.OpenBackendEntry(kSimpleGET_Transaction.url, &entry));
- net::HttpResponseInfo response;
- bool truncated = false;
- EXPECT_TRUE(MockHttpCache::ReadResponseInfo(entry, &response, &truncated));
- EXPECT_TRUE(truncated);
- entry->Close();
-
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that we don't mark an entry as truncated when we read everything.
-TEST(HttpCache, DontSetTruncatedFlag) {
- MockHttpCache cache;
-
- MockTransaction transaction(kSimpleGET_Transaction);
- transaction.response_headers =
- "Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
- "Content-Length: 22\n"
- "Etag: \"foopy\"\n";
- AddMockTransaction(&transaction);
- MockHttpRequest request(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::OK, c->callback.GetResult(rv));
-
- // Read everything.
- scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(22));
- rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
- EXPECT_EQ(buf->size(), c->callback.GetResult(rv));
-
- // Destroy the transaction.
- c->trans.reset();
-
- // Verify that the entry is not marked as truncated.
- disk_cache::Entry* entry;
- ASSERT_TRUE(cache.OpenBackendEntry(kSimpleGET_Transaction.url, &entry));
- net::HttpResponseInfo response;
- bool truncated = true;
- EXPECT_TRUE(MockHttpCache::ReadResponseInfo(entry, &response, &truncated));
- EXPECT_FALSE(truncated);
- entry->Close();
-
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that we can continue with a request that was interrupted.
-TEST(HttpCache, GET_IncompleteResource) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
-
- std::string raw_headers("HTTP/1.1 200 OK\n"
- "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
- "ETag: \"foo\"\n"
- "Accept-Ranges: bytes\n"
- "Content-Length: 80\n");
- CreateTruncatedEntry(raw_headers, &cache);
-
- // Now make a regular request.
- std::string headers;
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = EXTRA_HEADER;
- transaction.data = kFullRangeData;
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- // We update the headers with the ones received while revalidating.
- std::string expected_headers(
- "HTTP/1.1 200 OK\n"
- "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
- "Accept-Ranges: bytes\n"
- "ETag: \"foo\"\n"
- "Content-Length: 80\n");
-
- EXPECT_EQ(expected_headers, headers);
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Verify that the disk entry was updated.
- disk_cache::Entry* entry;
- ASSERT_TRUE(cache.OpenBackendEntry(kRangeGET_TransactionOK.url, &entry));
- EXPECT_EQ(80, entry->GetDataSize(1));
- bool truncated = true;
- net::HttpResponseInfo response;
- EXPECT_TRUE(MockHttpCache::ReadResponseInfo(entry, &response, &truncated));
- EXPECT_FALSE(truncated);
- entry->Close();
-
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-// Tests the handling of no-store when revalidating a truncated entry.
-TEST(HttpCache, GET_IncompleteResource_NoStore) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
-
- std::string raw_headers("HTTP/1.1 200 OK\n"
- "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
- "ETag: \"foo\"\n"
- "Accept-Ranges: bytes\n"
- "Content-Length: 80\n");
- CreateTruncatedEntry(raw_headers, &cache);
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-
- // Now make a regular request.
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = EXTRA_HEADER;
- std::string response_headers(transaction.response_headers);
- response_headers += ("Cache-Control: no-store\n");
- transaction.response_headers = response_headers.c_str();
- transaction.data = kFullRangeData;
- AddMockTransaction(&transaction);
-
- std::string headers;
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- // We update the headers with the ones received while revalidating.
- std::string expected_headers(
- "HTTP/1.1 200 OK\n"
- "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
- "Accept-Ranges: bytes\n"
- "Cache-Control: no-store\n"
- "ETag: \"foo\"\n"
- "Content-Length: 80\n");
-
- EXPECT_EQ(expected_headers, headers);
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Verify that the disk entry was deleted.
- disk_cache::Entry* entry;
- EXPECT_FALSE(cache.OpenBackendEntry(kRangeGET_TransactionOK.url, &entry));
- RemoveMockTransaction(&transaction);
-}
-
-// Tests cancelling a request after the server sent no-store.
-TEST(HttpCache, GET_IncompleteResource_Cancel) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
-
- std::string raw_headers("HTTP/1.1 200 OK\n"
- "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
- "ETag: \"foo\"\n"
- "Accept-Ranges: bytes\n"
- "Content-Length: 80\n");
- CreateTruncatedEntry(raw_headers, &cache);
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-
- // Now make a regular request.
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = EXTRA_HEADER;
- std::string response_headers(transaction.response_headers);
- response_headers += ("Cache-Control: no-store\n");
- transaction.response_headers = response_headers.c_str();
- transaction.data = kFullRangeData;
- AddMockTransaction(&transaction);
-
- MockHttpRequest request(transaction);
- Context* c = new Context();
-
- int rv = cache.CreateTransaction(&c->trans);
- ASSERT_EQ(net::OK, rv);
-
- // Queue another request to this transaction. We have to start this request
- // before the first one gets the response from the server and dooms the entry,
- // otherwise it will just create a new entry without being queued to the first
- // request.
- Context* pending = new Context();
- ASSERT_EQ(net::OK, cache.CreateTransaction(&pending->trans));
-
- rv = c->trans->Start(&request, c->callback.callback(), net::BoundNetLog());
- EXPECT_EQ(net::ERR_IO_PENDING,
- pending->trans->Start(&request, pending->callback.callback(),
- net::BoundNetLog()));
- EXPECT_EQ(net::OK, c->callback.GetResult(rv));
-
- // Make sure that the entry has some data stored.
- scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(5));
- rv = c->trans->Read(buf.get(), buf->size(), c->callback.callback());
- EXPECT_EQ(5, c->callback.GetResult(rv));
-
- // Cancel the requests.
- delete c;
- delete pending;
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-
- base::MessageLoop::current()->RunUntilIdle();
- RemoveMockTransaction(&transaction);
-}
-
-// Tests that we delete truncated entries if the server changes its mind midway.
-TEST(HttpCache, GET_IncompleteResource2) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
-
- // Content-length will be intentionally bad.
- std::string raw_headers("HTTP/1.1 200 OK\n"
- "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
- "ETag: \"foo\"\n"
- "Accept-Ranges: bytes\n"
- "Content-Length: 50\n");
- CreateTruncatedEntry(raw_headers, &cache);
-
- // Now make a regular request. We expect the code to fail the validation and
- // retry the request without using byte ranges.
- std::string headers;
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = EXTRA_HEADER;
- transaction.data = "Not a range";
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- // The server will return 200 instead of a byte range.
- std::string expected_headers(
- "HTTP/1.1 200 OK\n"
- "Date: Wed, 28 Nov 2007 09:40:09 GMT\n");
-
- EXPECT_EQ(expected_headers, headers);
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Verify that the disk entry was deleted.
- disk_cache::Entry* entry;
- ASSERT_FALSE(cache.OpenBackendEntry(kRangeGET_TransactionOK.url, &entry));
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-// Tests that we always validate a truncated request.
-TEST(HttpCache, GET_IncompleteResource3) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
-
- // This should not require validation for 10 hours.
- std::string raw_headers("HTTP/1.1 200 OK\n"
- "Last-Modified: Sat, 18 Apr 2009 01:10:43 GMT\n"
- "ETag: \"foo\"\n"
- "Cache-Control: max-age= 36000\n"
- "Accept-Ranges: bytes\n"
- "Content-Length: 80\n");
- CreateTruncatedEntry(raw_headers, &cache);
-
- // Now make a regular request.
- std::string headers;
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = EXTRA_HEADER;
- transaction.data = kFullRangeData;
-
- scoped_ptr<Context> c(new Context);
- int rv = cache.CreateTransaction(&c->trans);
- ASSERT_EQ(net::OK, rv);
-
- MockHttpRequest request(transaction);
- rv = c->trans->Start(&request, c->callback.callback(), net::BoundNetLog());
- EXPECT_EQ(net::OK, c->callback.GetResult(rv));
-
- // We should have checked with the server before finishing Start().
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-// Tests that we handle 401s for truncated resources.
-TEST(HttpCache, GET_IncompleteResourceWithAuth) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
-
- std::string raw_headers("HTTP/1.1 200 OK\n"
- "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
- "ETag: \"foo\"\n"
- "Accept-Ranges: bytes\n"
- "Content-Length: 80\n");
- CreateTruncatedEntry(raw_headers, &cache);
-
- // Now make a regular request.
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = "X-Require-Mock-Auth: dummy\r\n"
- EXTRA_HEADER;
- transaction.data = kFullRangeData;
- RangeTransactionServer handler;
-
- scoped_ptr<Context> c(new Context);
- int rv = cache.CreateTransaction(&c->trans);
- ASSERT_EQ(net::OK, rv);
-
- MockHttpRequest request(transaction);
- rv = c->trans->Start(&request, c->callback.callback(), net::BoundNetLog());
- EXPECT_EQ(net::OK, c->callback.GetResult(rv));
-
- const net::HttpResponseInfo* response = c->trans->GetResponseInfo();
- ASSERT_TRUE(response);
- ASSERT_EQ(401, response->headers->response_code());
- rv = c->trans->RestartWithAuth(net::AuthCredentials(),
- c->callback.callback());
- EXPECT_EQ(net::OK, c->callback.GetResult(rv));
- response = c->trans->GetResponseInfo();
- ASSERT_TRUE(response);
- ASSERT_EQ(200, response->headers->response_code());
-
- ReadAndVerifyTransaction(c->trans.get(), transaction);
- c.reset(); // The destructor could delete the entry.
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
-
- // Verify that the entry was not deleted.
- disk_cache::Entry* entry;
- ASSERT_TRUE(cache.OpenBackendEntry(kRangeGET_TransactionOK.url, &entry));
- entry->Close();
-
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-// Tests that we cache a 200 response to the validation request.
-TEST(HttpCache, GET_IncompleteResource4) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
-
- std::string raw_headers("HTTP/1.1 200 OK\n"
- "Last-Modified: Sat, 18 Apr 2009 01:10:43 GMT\n"
- "ETag: \"foo\"\n"
- "Accept-Ranges: bytes\n"
- "Content-Length: 80\n");
- CreateTruncatedEntry(raw_headers, &cache);
-
- // Now make a regular request.
- std::string headers;
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = EXTRA_HEADER;
- transaction.data = "Not a range";
- RangeTransactionServer handler;
- handler.set_bad_200(true);
- RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Verify that the disk entry was updated.
- disk_cache::Entry* entry;
- ASSERT_TRUE(cache.OpenBackendEntry(kRangeGET_TransactionOK.url, &entry));
- EXPECT_EQ(11, entry->GetDataSize(1));
- bool truncated = true;
- net::HttpResponseInfo response;
- EXPECT_TRUE(MockHttpCache::ReadResponseInfo(entry, &response, &truncated));
- EXPECT_FALSE(truncated);
- entry->Close();
-
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-// Tests that when we cancel a request that was interrupted, we mark it again
-// as truncated.
-TEST(HttpCache, GET_CancelIncompleteResource) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
-
- std::string raw_headers("HTTP/1.1 200 OK\n"
- "Last-Modified: Sat, 18 Apr 2009 01:10:43 GMT\n"
- "ETag: \"foo\"\n"
- "Accept-Ranges: bytes\n"
- "Content-Length: 80\n");
- CreateTruncatedEntry(raw_headers, &cache);
-
- // Now make a regular request.
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = EXTRA_HEADER;
-
- MockHttpRequest request(transaction);
- 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::OK, c->callback.GetResult(rv));
-
- // Read 20 bytes from the cache, and 10 from the net.
- scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(100));
- rv = c->trans->Read(buf.get(), 20, c->callback.callback());
- EXPECT_EQ(20, c->callback.GetResult(rv));
- rv = c->trans->Read(buf.get(), 10, c->callback.callback());
- EXPECT_EQ(10, c->callback.GetResult(rv));
-
- // At this point, we are already reading so canceling the request should leave
- // a truncated one.
- delete c;
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Verify that the disk entry was updated: now we have 30 bytes.
- disk_cache::Entry* entry;
- ASSERT_TRUE(cache.OpenBackendEntry(kRangeGET_TransactionOK.url, &entry));
- EXPECT_EQ(30, entry->GetDataSize(1));
- bool truncated = false;
- net::HttpResponseInfo response;
- EXPECT_TRUE(MockHttpCache::ReadResponseInfo(entry, &response, &truncated));
- EXPECT_TRUE(truncated);
- entry->Close();
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-// Tests that we can handle range requests when we have a truncated entry.
-TEST(HttpCache, RangeGET_IncompleteResource) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
-
- // Content-length will be intentionally bogus.
- std::string raw_headers("HTTP/1.1 200 OK\n"
- "Last-Modified: something\n"
- "ETag: \"foo\"\n"
- "Accept-Ranges: bytes\n"
- "Content-Length: 10\n");
- CreateTruncatedEntry(raw_headers, &cache);
-
- // Now make a range request.
- std::string headers;
- RunTransactionTestWithResponse(cache.http_cache(), kRangeGET_TransactionOK,
- &headers);
-
- Verify206Response(headers, 40, 49);
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-TEST(HttpCache, SyncRead) {
- MockHttpCache cache;
-
- // This test ensures that a read that completes synchronously does not cause
- // any problems.
-
- ScopedMockTransaction transaction(kSimpleGET_Transaction);
- transaction.test_mode |= (TEST_MODE_SYNC_CACHE_START |
- TEST_MODE_SYNC_CACHE_READ |
- TEST_MODE_SYNC_CACHE_WRITE);
-
- MockHttpRequest r1(transaction),
- r2(transaction),
- r3(transaction);
-
- TestTransactionConsumer c1(net::DEFAULT_PRIORITY, cache.http_cache()),
- c2(net::DEFAULT_PRIORITY, cache.http_cache()),
- c3(net::DEFAULT_PRIORITY, cache.http_cache());
-
- c1.Start(&r1, net::BoundNetLog());
-
- r2.load_flags |= net::LOAD_ONLY_FROM_CACHE;
- c2.Start(&r2, net::BoundNetLog());
-
- r3.load_flags |= net::LOAD_ONLY_FROM_CACHE;
- c3.Start(&r3, net::BoundNetLog());
-
- base::MessageLoop::current()->Run();
-
- EXPECT_TRUE(c1.is_done());
- EXPECT_TRUE(c2.is_done());
- EXPECT_TRUE(c3.is_done());
-
- EXPECT_EQ(net::OK, c1.error());
- EXPECT_EQ(net::OK, c2.error());
- EXPECT_EQ(net::OK, c3.error());
-}
-
-TEST(HttpCache, ValidationResultsIn200) {
- MockHttpCache cache;
-
- // This test ensures that a conditional request, which results in a 200
- // instead of a 304, properly truncates the existing response data.
-
- // write to the cache
- RunTransactionTest(cache.http_cache(), kETagGET_Transaction);
-
- // force this transaction to validate the cache
- MockTransaction transaction(kETagGET_Transaction);
- transaction.load_flags |= net::LOAD_VALIDATE_CACHE;
- RunTransactionTest(cache.http_cache(), transaction);
-
- // read from the cache
- RunTransactionTest(cache.http_cache(), kETagGET_Transaction);
-}
-
-TEST(HttpCache, CachedRedirect) {
- MockHttpCache cache;
-
- ScopedMockTransaction kTestTransaction(kSimpleGET_Transaction);
- kTestTransaction.status = "HTTP/1.1 301 Moved Permanently";
- kTestTransaction.response_headers = "Location: http://www.bar.com/\n";
-
- MockHttpRequest request(kTestTransaction);
- net::TestCompletionCallback callback;
-
- // Write to the cache.
- {
- 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);
-
- const net::HttpResponseInfo* info = trans->GetResponseInfo();
- ASSERT_TRUE(info);
-
- EXPECT_EQ(info->headers->response_code(), 301);
-
- std::string location;
- info->headers->EnumerateHeader(NULL, "Location", &location);
- EXPECT_EQ(location, "http://www.bar.com/");
-
- // Mark the transaction as completed so it is cached.
- trans->DoneReading();
-
- // Destroy transaction when going out of scope. We have not actually
- // read the response body -- want to test that it is still getting cached.
- }
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Active entries in the cache are not retired synchronously. Make
- // sure the next run hits the MockHttpCache and open_count is
- // correct.
- base::MessageLoop::current()->RunUntilIdle();
-
- // Read from the cache.
- {
- 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);
-
- const net::HttpResponseInfo* info = trans->GetResponseInfo();
- ASSERT_TRUE(info);
-
- EXPECT_EQ(info->headers->response_code(), 301);
-
- std::string location;
- info->headers->EnumerateHeader(NULL, "Location", &location);
- EXPECT_EQ(location, "http://www.bar.com/");
-
- // Mark the transaction as completed so it is cached.
- trans->DoneReading();
-
- // Destroy transaction when going out of scope. We have not actually
- // read the response body -- want to test that it is still getting cached.
- }
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-}
-
-// Verify that no-cache resources are stored in cache, but are not fetched from
-// cache during normal loads.
-TEST(HttpCache, CacheControlNoCacheNormalLoad) {
- MockHttpCache cache;
-
- ScopedMockTransaction transaction(kSimpleGET_Transaction);
- transaction.response_headers = "cache-control: no-cache\n";
-
- // Initial load.
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Try loading again; it should result in a network fetch.
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- disk_cache::Entry* entry;
- EXPECT_TRUE(cache.OpenBackendEntry(transaction.url, &entry));
- entry->Close();
-}
-
-// Verify that no-cache resources are stored in cache and fetched from cache
-// when the LOAD_PREFERRING_CACHE flag is set.
-TEST(HttpCache, CacheControlNoCacheHistoryLoad) {
- MockHttpCache cache;
-
- ScopedMockTransaction transaction(kSimpleGET_Transaction);
- transaction.response_headers = "cache-control: no-cache\n";
-
- // Initial load.
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // Try loading again with LOAD_PREFERRING_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());
-
- disk_cache::Entry* entry;
- EXPECT_TRUE(cache.OpenBackendEntry(transaction.url, &entry));
- entry->Close();
-}
-
-TEST(HttpCache, CacheControlNoStore) {
- MockHttpCache cache;
-
- ScopedMockTransaction transaction(kSimpleGET_Transaction);
- transaction.response_headers = "cache-control: no-store\n";
-
- // initial load
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // try loading again; it should result in a network fetch
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-
- disk_cache::Entry* entry;
- EXPECT_FALSE(cache.OpenBackendEntry(transaction.url, &entry));
-}
-
-TEST(HttpCache, CacheControlNoStore2) {
- // this test is similar to the above test, except that the initial response
- // is cachable, but when it is validated, no-store is received causing the
- // cached document to be deleted.
- MockHttpCache cache;
-
- ScopedMockTransaction transaction(kETagGET_Transaction);
-
- // initial load
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // try loading again; it should result in a network fetch
- transaction.load_flags = net::LOAD_VALIDATE_CACHE;
- transaction.response_headers = "cache-control: no-store\n";
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- disk_cache::Entry* entry;
- EXPECT_FALSE(cache.OpenBackendEntry(transaction.url, &entry));
-}
-
-TEST(HttpCache, CacheControlNoStore3) {
- // this test is similar to the above test, except that the response is a 304
- // instead of a 200. this should never happen in practice, but it seems like
- // a good thing to verify that we still destroy the cache entry.
- MockHttpCache cache;
-
- ScopedMockTransaction transaction(kETagGET_Transaction);
-
- // initial load
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- // try loading again; it should result in a network fetch
- transaction.load_flags = net::LOAD_VALIDATE_CACHE;
- transaction.response_headers = "cache-control: no-store\n";
- transaction.status = "HTTP/1.1 304 Not Modified";
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-
- disk_cache::Entry* entry;
- EXPECT_FALSE(cache.OpenBackendEntry(transaction.url, &entry));
-}
-
-// Ensure that we don't cache requests served over bad HTTPS.
-TEST(HttpCache, SimpleGET_SSLError) {
- MockHttpCache cache;
-
- MockTransaction transaction = kSimpleGET_Transaction;
- transaction.cert_status = net::CERT_STATUS_REVOKED;
- ScopedMockTransaction scoped_transaction(transaction);
-
- // write to the cache
- RunTransactionTest(cache.http_cache(), transaction);
-
- // Test that it was not cached.
- transaction.load_flags |= 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);
-}
-
-// Ensure that we don't crash by if left-behind transactions.
-TEST(HttpCache, OutlivedTransactions) {
- MockHttpCache* cache = new MockHttpCache;
-
- scoped_ptr<net::HttpTransaction> trans;
- EXPECT_EQ(net::OK, cache->CreateTransaction(&trans));
-
- delete cache;
- trans.reset();
-}
-
-// Test that the disabled mode works.
-TEST(HttpCache, CacheDisabledMode) {
- MockHttpCache cache;
-
- // write to the cache
- RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
-
- // go into disabled mode
- cache.http_cache()->set_mode(net::HttpCache::DISABLE);
-
- // force this transaction to write to the cache again
- MockTransaction transaction(kSimpleGET_Transaction);
-
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-}
-
-// Other tests check that the response headers of the cached response
-// get updated on 304. Here we specifically check that the
-// HttpResponseHeaders::request_time and HttpResponseHeaders::response_time
-// fields also gets updated.
-// http://crbug.com/20594.
-TEST(HttpCache, UpdatesRequestResponseTimeOn304) {
- MockHttpCache cache;
-
- const char kUrl[] = "http://foobar";
- const char kData[] = "body";
-
- MockTransaction mock_network_response = { 0 };
- mock_network_response.url = kUrl;
-
- AddMockTransaction(&mock_network_response);
-
- // Request |kUrl|, causing |kNetResponse1| to be written to the cache.
-
- MockTransaction request = { 0 };
- request.url = kUrl;
- request.method = "GET";
- request.request_headers = "\r\n";
- request.data = kData;
-
- static const Response kNetResponse1 = {
- "HTTP/1.1 200 OK",
- "Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
- "Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
- kData
- };
-
- kNetResponse1.AssignTo(&mock_network_response);
-
- RunTransactionTest(cache.http_cache(), request);
-
- // Request |kUrl| again, this time validating the cache and getting
- // a 304 back.
-
- request.load_flags = net::LOAD_VALIDATE_CACHE;
-
- static const Response kNetResponse2 = {
- "HTTP/1.1 304 Not Modified",
- "Date: Wed, 22 Jul 2009 03:15:26 GMT\n",
- ""
- };
-
- kNetResponse2.AssignTo(&mock_network_response);
-
- base::Time request_time = base::Time() + base::TimeDelta::FromHours(1234);
- base::Time response_time = base::Time() + base::TimeDelta::FromHours(1235);
-
- mock_network_response.request_time = request_time;
- mock_network_response.response_time = response_time;
-
- net::HttpResponseInfo response;
- RunTransactionTestWithResponseInfo(cache.http_cache(), request, &response);
-
- // The request and response times should have been updated.
- EXPECT_EQ(request_time.ToInternalValue(),
- response.request_time.ToInternalValue());
- EXPECT_EQ(response_time.ToInternalValue(),
- response.response_time.ToInternalValue());
-
- std::string headers;
- response.headers->GetNormalizedHeaders(&headers);
-
- EXPECT_EQ("HTTP/1.1 200 OK\n"
- "Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
- "Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
- headers);
-
- RemoveMockTransaction(&mock_network_response);
-}
-
-// Tests that we can write metadata to an entry.
-TEST(HttpCache, WriteMetadata_OK) {
- MockHttpCache cache;
-
- // Write to the cache
- net::HttpResponseInfo response;
- RunTransactionTestWithResponseInfo(cache.http_cache(), kSimpleGET_Transaction,
- &response);
- EXPECT_TRUE(response.metadata.get() == NULL);
-
- // Trivial call.
- cache.http_cache()->WriteMetadata(GURL("foo"), net::DEFAULT_PRIORITY,
- Time::Now().ToDoubleT(), NULL, 0);
-
- // Write meta data to the same entry.
- scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(50));
- memset(buf->data(), 0, buf->size());
- base::strlcpy(buf->data(), "Hi there", buf->size());
- cache.http_cache()->WriteMetadata(
- GURL(kSimpleGET_Transaction.url), net::DEFAULT_PRIORITY,
- response.response_time.ToDoubleT(), buf.get(), buf->size());
-
- // Release the buffer before the operation takes place.
- buf = NULL;
-
- // Makes sure we finish pending operations.
- base::MessageLoop::current()->RunUntilIdle();
-
- RunTransactionTestWithResponseInfo(cache.http_cache(), kSimpleGET_Transaction,
- &response);
- ASSERT_TRUE(response.metadata.get() != NULL);
- EXPECT_EQ(50, response.metadata->size());
- EXPECT_EQ(0, strcmp(response.metadata->data(), "Hi there"));
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(2, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-}
-
-// Tests that we only write metadata to an entry if the time stamp matches.
-TEST(HttpCache, WriteMetadata_Fail) {
- MockHttpCache cache;
-
- // Write to the cache
- net::HttpResponseInfo response;
- RunTransactionTestWithResponseInfo(cache.http_cache(), kSimpleGET_Transaction,
- &response);
- EXPECT_TRUE(response.metadata.get() == NULL);
-
- // Attempt to write meta data to the same entry.
- scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(50));
- memset(buf->data(), 0, buf->size());
- base::strlcpy(buf->data(), "Hi there", buf->size());
- base::Time expected_time = response.response_time -
- base::TimeDelta::FromMilliseconds(20);
- cache.http_cache()->WriteMetadata(
- GURL(kSimpleGET_Transaction.url), net::DEFAULT_PRIORITY,
- expected_time.ToDoubleT(), buf.get(), buf->size());
-
- // Makes sure we finish pending operations.
- base::MessageLoop::current()->RunUntilIdle();
-
- RunTransactionTestWithResponseInfo(cache.http_cache(), kSimpleGET_Transaction,
- &response);
- EXPECT_TRUE(response.metadata.get() == NULL);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(2, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-}
-
-// Tests that we can read metadata after validating the entry and with READ mode
-// transactions.
-TEST(HttpCache, ReadMetadata) {
- MockHttpCache cache;
-
- // Write to the cache
- net::HttpResponseInfo response;
- RunTransactionTestWithResponseInfo(cache.http_cache(),
- kTypicalGET_Transaction, &response);
- EXPECT_TRUE(response.metadata.get() == NULL);
-
- // Write meta data to the same entry.
- scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(50));
- memset(buf->data(), 0, buf->size());
- base::strlcpy(buf->data(), "Hi there", buf->size());
- cache.http_cache()->WriteMetadata(
- GURL(kTypicalGET_Transaction.url), net::DEFAULT_PRIORITY,
- response.response_time.ToDoubleT(), buf.get(), buf->size());
-
- // Makes sure we finish pending operations.
- base::MessageLoop::current()->RunUntilIdle();
-
- // Start with a READ mode transaction.
- MockTransaction trans1(kTypicalGET_Transaction);
- trans1.load_flags = net::LOAD_ONLY_FROM_CACHE;
-
- RunTransactionTestWithResponseInfo(cache.http_cache(), trans1, &response);
- ASSERT_TRUE(response.metadata.get() != NULL);
- EXPECT_EQ(50, response.metadata->size());
- EXPECT_EQ(0, strcmp(response.metadata->data(), "Hi there"));
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(2, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
- base::MessageLoop::current()->RunUntilIdle();
-
- // Now make sure that the entry is re-validated with the server.
- trans1.load_flags = net::LOAD_VALIDATE_CACHE;
- trans1.status = "HTTP/1.1 304 Not Modified";
- AddMockTransaction(&trans1);
-
- response.metadata = NULL;
- RunTransactionTestWithResponseInfo(cache.http_cache(), trans1, &response);
- EXPECT_TRUE(response.metadata.get() != NULL);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(3, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
- base::MessageLoop::current()->RunUntilIdle();
- RemoveMockTransaction(&trans1);
-
- // Now return 200 when validating the entry so the metadata will be lost.
- MockTransaction trans2(kTypicalGET_Transaction);
- trans2.load_flags = net::LOAD_VALIDATE_CACHE;
- RunTransactionTestWithResponseInfo(cache.http_cache(), trans2, &response);
- EXPECT_TRUE(response.metadata.get() == NULL);
-
- EXPECT_EQ(3, cache.network_layer()->transaction_count());
- EXPECT_EQ(4, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-}
-
-// Tests that we don't mark entries as truncated when a filter detects the end
-// of the stream.
-TEST(HttpCache, FilterCompletion) {
- MockHttpCache cache;
- net::TestCompletionCallback callback;
-
- {
- scoped_ptr<net::HttpTransaction> trans;
- ASSERT_EQ(net::OK, cache.CreateTransaction(&trans));
-
- MockHttpRequest request(kSimpleGET_Transaction);
- int rv = trans->Start(&request, callback.callback(), net::BoundNetLog());
- EXPECT_EQ(net::OK, callback.GetResult(rv));
-
- scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
- rv = trans->Read(buf.get(), 256, callback.callback());
- EXPECT_GT(callback.GetResult(rv), 0);
-
- // Now make sure that the entry is preserved.
- trans->DoneReading();
- }
-
- // Make sure that the ActiveEntry is gone.
- base::MessageLoop::current()->RunUntilIdle();
-
- // Read from the cache.
- RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-}
-
-// Tests that we don't mark entries as truncated and release the cache
-// entry when DoneReading() is called before any Read() calls, such as
-// for a redirect.
-TEST(HttpCache, DoneReading) {
- MockHttpCache cache;
- net::TestCompletionCallback callback;
-
- ScopedMockTransaction transaction(kSimpleGET_Transaction);
- transaction.data = "";
-
- scoped_ptr<net::HttpTransaction> trans;
- ASSERT_EQ(net::OK, cache.CreateTransaction(&trans));
-
- MockHttpRequest request(transaction);
- int rv = trans->Start(&request, callback.callback(), net::BoundNetLog());
- EXPECT_EQ(net::OK, callback.GetResult(rv));
-
- trans->DoneReading();
- // Leave the transaction around.
-
- // Make sure that the ActiveEntry is gone.
- base::MessageLoop::current()->RunUntilIdle();
-
- // Read from the cache. This should not deadlock.
- RunTransactionTest(cache.http_cache(), transaction);
-
- EXPECT_EQ(1, cache.network_layer()->transaction_count());
- EXPECT_EQ(1, cache.disk_cache()->open_count());
- EXPECT_EQ(1, cache.disk_cache()->create_count());
-}
-
-// Tests that we stop caching when told.
-TEST(HttpCache, StopCachingDeletesEntry) {
- MockHttpCache cache;
- net::TestCompletionCallback callback;
- MockHttpRequest request(kSimpleGET_Transaction);
-
- {
- 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));
-
- scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
- rv = trans->Read(buf.get(), 10, callback.callback());
- EXPECT_EQ(10, callback.GetResult(rv));
-
- trans->StopCaching();
-
- // We should be able to keep reading.
- rv = trans->Read(buf.get(), 256, callback.callback());
- EXPECT_GT(callback.GetResult(rv), 0);
- rv = trans->Read(buf.get(), 256, callback.callback());
- EXPECT_EQ(0, callback.GetResult(rv));
- }
-
- // Make sure that the ActiveEntry is gone.
- base::MessageLoop::current()->RunUntilIdle();
-
- // Verify that the entry is gone.
- RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-}
-
-// Tests that we stop caching when told, even if DoneReading is called
-// after StopCaching.
-TEST(HttpCache, StopCachingThenDoneReadingDeletesEntry) {
- MockHttpCache cache;
- net::TestCompletionCallback callback;
- MockHttpRequest request(kSimpleGET_Transaction);
-
- {
- 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));
-
- scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
- rv = trans->Read(buf.get(), 10, callback.callback());
- EXPECT_EQ(10, callback.GetResult(rv));
-
- trans->StopCaching();
-
- // We should be able to keep reading.
- rv = trans->Read(buf.get(), 256, callback.callback());
- EXPECT_GT(callback.GetResult(rv), 0);
- rv = trans->Read(buf.get(), 256, callback.callback());
- EXPECT_EQ(0, callback.GetResult(rv));
-
- // We should be able to call DoneReading.
- trans->DoneReading();
- }
-
- // Make sure that the ActiveEntry is gone.
- base::MessageLoop::current()->RunUntilIdle();
-
- // Verify that the entry is gone.
- RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-}
-
-// Tests that we stop caching when told, when using auth.
-TEST(HttpCache, StopCachingWithAuthDeletesEntry) {
- MockHttpCache cache;
- net::TestCompletionCallback callback;
- MockTransaction mock_transaction(kSimpleGET_Transaction);
- mock_transaction.status = "HTTP/1.1 401 Unauthorized";
- AddMockTransaction(&mock_transaction);
- MockHttpRequest request(mock_transaction);
-
- {
- 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));
-
- trans->StopCaching();
-
- scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
- rv = trans->Read(buf.get(), 10, callback.callback());
- EXPECT_EQ(callback.GetResult(rv), 10);
- }
- RemoveMockTransaction(&mock_transaction);
-
- // Make sure that the ActiveEntry is gone.
- base::MessageLoop::current()->RunUntilIdle();
-
- // Verify that the entry is gone.
- RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-}
-
-// Tests that when we are told to stop caching we don't throw away valid data.
-TEST(HttpCache, StopCachingSavesEntry) {
- MockHttpCache cache;
- net::TestCompletionCallback callback;
- MockHttpRequest request(kSimpleGET_Transaction);
-
- {
- scoped_ptr<net::HttpTransaction> trans;
- ASSERT_EQ(net::OK, cache.CreateTransaction(&trans));
-
- // Force a response that can be resumed.
- MockTransaction mock_transaction(kSimpleGET_Transaction);
- AddMockTransaction(&mock_transaction);
- mock_transaction.response_headers = "Cache-Control: max-age=10000\n"
- "Content-Length: 42\n"
- "Etag: \"foo\"\n";
-
- int rv = trans->Start(&request, callback.callback(), net::BoundNetLog());
- EXPECT_EQ(net::OK, callback.GetResult(rv));
-
- scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
- rv = trans->Read(buf.get(), 10, callback.callback());
- EXPECT_EQ(callback.GetResult(rv), 10);
-
- trans->StopCaching();
-
- // We should be able to keep reading.
- rv = trans->Read(buf.get(), 256, callback.callback());
- EXPECT_GT(callback.GetResult(rv), 0);
- rv = trans->Read(buf.get(), 256, callback.callback());
- EXPECT_EQ(callback.GetResult(rv), 0);
-
- RemoveMockTransaction(&mock_transaction);
- }
-
- // Verify that the entry is marked as incomplete.
- disk_cache::Entry* entry;
- ASSERT_TRUE(cache.OpenBackendEntry(kSimpleGET_Transaction.url, &entry));
- net::HttpResponseInfo response;
- bool truncated = false;
- EXPECT_TRUE(MockHttpCache::ReadResponseInfo(entry, &response, &truncated));
- EXPECT_TRUE(truncated);
- entry->Close();
-}
-
-// Tests that we handle truncated enries when StopCaching is called.
-TEST(HttpCache, StopCachingTruncatedEntry) {
- MockHttpCache cache;
- net::TestCompletionCallback callback;
- MockHttpRequest request(kRangeGET_TransactionOK);
- request.extra_headers.Clear();
- request.extra_headers.AddHeaderFromString(EXTRA_HEADER_LINE);
- AddMockTransaction(&kRangeGET_TransactionOK);
-
- std::string raw_headers("HTTP/1.1 200 OK\n"
- "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
- "ETag: \"foo\"\n"
- "Accept-Ranges: bytes\n"
- "Content-Length: 80\n");
- CreateTruncatedEntry(raw_headers, &cache);
-
- {
- // Now make a regular request.
- 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));
-
- scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
- rv = trans->Read(buf.get(), 10, callback.callback());
- EXPECT_EQ(callback.GetResult(rv), 10);
-
- // This is actually going to do nothing.
- trans->StopCaching();
-
- // We should be able to keep reading.
- rv = trans->Read(buf.get(), 256, callback.callback());
- EXPECT_GT(callback.GetResult(rv), 0);
- rv = trans->Read(buf.get(), 256, callback.callback());
- EXPECT_GT(callback.GetResult(rv), 0);
- rv = trans->Read(buf.get(), 256, callback.callback());
- EXPECT_EQ(callback.GetResult(rv), 0);
- }
-
- // Verify that the disk entry was updated.
- disk_cache::Entry* entry;
- ASSERT_TRUE(cache.OpenBackendEntry(kRangeGET_TransactionOK.url, &entry));
- EXPECT_EQ(80, entry->GetDataSize(1));
- bool truncated = true;
- net::HttpResponseInfo response;
- EXPECT_TRUE(MockHttpCache::ReadResponseInfo(entry, &response, &truncated));
- EXPECT_FALSE(truncated);
- entry->Close();
-
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-// Tests that we detect truncated resources from the net when there is
-// a Content-Length header.
-TEST(HttpCache, TruncatedByContentLength) {
- MockHttpCache cache;
- net::TestCompletionCallback callback;
-
- MockTransaction transaction(kSimpleGET_Transaction);
- AddMockTransaction(&transaction);
- transaction.response_headers = "Cache-Control: max-age=10000\n"
- "Content-Length: 100\n";
- RunTransactionTest(cache.http_cache(), transaction);
- RemoveMockTransaction(&transaction);
-
- // Read from the cache.
- RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
-
- EXPECT_EQ(2, cache.network_layer()->transaction_count());
- EXPECT_EQ(0, cache.disk_cache()->open_count());
- EXPECT_EQ(2, cache.disk_cache()->create_count());
-}
-
-// Tests that we actually flag entries as truncated when we detect an error
-// from the net.
-TEST(HttpCache, TruncatedByContentLength2) {
- MockHttpCache cache;
- net::TestCompletionCallback callback;
-
- MockTransaction transaction(kSimpleGET_Transaction);
- AddMockTransaction(&transaction);
- transaction.response_headers = "Cache-Control: max-age=10000\n"
- "Content-Length: 100\n"
- "Etag: \"foo\"\n";
- RunTransactionTest(cache.http_cache(), transaction);
- RemoveMockTransaction(&transaction);
-
- // Verify that the entry is marked as incomplete.
- disk_cache::Entry* entry;
- ASSERT_TRUE(cache.OpenBackendEntry(kSimpleGET_Transaction.url, &entry));
- net::HttpResponseInfo response;
- bool truncated = false;
- EXPECT_TRUE(MockHttpCache::ReadResponseInfo(entry, &response, &truncated));
- EXPECT_TRUE(truncated);
- entry->Close();
-}
-
-// Make sure that calling SetPriority on a cache transaction passes on
-// its priority updates to its underlying network transaction.
-TEST(HttpCache, SetPriority) {
- MockHttpCache cache;
-
- scoped_ptr<net::HttpTransaction> trans;
- ASSERT_EQ(net::OK, cache.http_cache()->CreateTransaction(net::IDLE, &trans));
-
- // Shouldn't crash, but doesn't do anything either.
- trans->SetPriority(net::LOW);
-
- EXPECT_FALSE(cache.network_layer()->last_transaction());
- EXPECT_EQ(net::DEFAULT_PRIORITY,
- cache.network_layer()->last_create_transaction_priority());
-
- net::HttpRequestInfo info;
- info.url = GURL(kSimpleGET_Transaction.url);
- net::TestCompletionCallback callback;
- EXPECT_EQ(net::ERR_IO_PENDING,
- trans->Start(&info, callback.callback(), net::BoundNetLog()));
-
- EXPECT_TRUE(cache.network_layer()->last_transaction());
- if (cache.network_layer()->last_transaction()) {
- EXPECT_EQ(net::LOW,
- cache.network_layer()->last_create_transaction_priority());
- EXPECT_EQ(net::LOW,
- cache.network_layer()->last_transaction()->priority());
- }
-
- trans->SetPriority(net::HIGHEST);
-
- if (cache.network_layer()->last_transaction()) {
- EXPECT_EQ(net::LOW,
- cache.network_layer()->last_create_transaction_priority());
- EXPECT_EQ(net::HIGHEST,
- cache.network_layer()->last_transaction()->priority());
- }
-
- EXPECT_EQ(net::OK, callback.WaitForResult());
-}
-
-// Make sure that calling SetWebSocketHandshakeStreamCreateHelper on a cache
-// transaction passes on its argument to the underlying network transaction.
-TEST(HttpCache, SetWebSocketHandshakeStreamCreateHelper) {
- MockHttpCache cache;
-
- FakeWebSocketHandshakeStreamCreateHelper create_helper;
- scoped_ptr<net::HttpTransaction> trans;
- ASSERT_EQ(net::OK, cache.http_cache()->CreateTransaction(net::IDLE, &trans));
-
- EXPECT_FALSE(cache.network_layer()->last_transaction());
-
- net::HttpRequestInfo info;
- info.url = GURL(kSimpleGET_Transaction.url);
- net::TestCompletionCallback callback;
- EXPECT_EQ(net::ERR_IO_PENDING,
- trans->Start(&info, callback.callback(), net::BoundNetLog()));
-
- ASSERT_TRUE(cache.network_layer()->last_transaction());
- EXPECT_FALSE(cache.network_layer()->last_transaction()->
- websocket_handshake_stream_create_helper());
- trans->SetWebSocketHandshakeStreamCreateHelper(&create_helper);
- EXPECT_EQ(&create_helper,
- cache.network_layer()->last_transaction()->
- websocket_handshake_stream_create_helper());
- EXPECT_EQ(net::OK, callback.WaitForResult());
-}
-
-// Make sure that a cache transaction passes on its priority to
-// newly-created network transactions.
-TEST(HttpCache, SetPriorityNewTransaction) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
-
- std::string raw_headers("HTTP/1.1 200 OK\n"
- "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
- "ETag: \"foo\"\n"
- "Accept-Ranges: bytes\n"
- "Content-Length: 80\n");
- CreateTruncatedEntry(raw_headers, &cache);
-
- // Now make a regular request.
- std::string headers;
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = EXTRA_HEADER;
- transaction.data = kFullRangeData;
-
- scoped_ptr<net::HttpTransaction> trans;
- ASSERT_EQ(net::OK,
- cache.http_cache()->CreateTransaction(net::MEDIUM, &trans));
- EXPECT_EQ(net::DEFAULT_PRIORITY,
- cache.network_layer()->last_create_transaction_priority());
-
- MockHttpRequest info(transaction);
- net::TestCompletionCallback callback;
- EXPECT_EQ(net::ERR_IO_PENDING,
- trans->Start(&info, callback.callback(), net::BoundNetLog()));
- EXPECT_EQ(net::OK, callback.WaitForResult());
-
- EXPECT_EQ(net::MEDIUM,
- cache.network_layer()->last_create_transaction_priority());
-
- trans->SetPriority(net::HIGHEST);
- // Should trigger a new network transaction and pick up the new
- // priority.
- ReadAndVerifyTransaction(trans.get(), transaction);
-
- EXPECT_EQ(net::HIGHEST,
- cache.network_layer()->last_create_transaction_priority());
-
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-int64 RunTransactionAndGetReceivedBytes(
- MockHttpCache& cache,
- const MockTransaction& trans_info) {
- int64 received_bytes = -1;
- RunTransactionTestBase(cache.http_cache(), trans_info,
- MockHttpRequest(trans_info), NULL, net::BoundNetLog(),
- NULL, &received_bytes);
- return received_bytes;
-}
-
-int64 TransactionSize(const MockTransaction& transaction) {
- return strlen(transaction.status) + strlen(transaction.response_headers) +
- strlen(transaction.data);
-}
-
-TEST(HttpCache, ReceivedBytesCacheMissAndThenHit) {
- MockHttpCache cache;
-
- MockTransaction transaction(kSimpleGET_Transaction);
- int64 received_bytes = RunTransactionAndGetReceivedBytes(cache, transaction);
- EXPECT_EQ(TransactionSize(transaction), received_bytes);
-
- received_bytes = RunTransactionAndGetReceivedBytes(cache, transaction);
- EXPECT_EQ(0, received_bytes);
-}
-
-TEST(HttpCache, ReceivedBytesConditionalRequest304) {
- MockHttpCache cache;
-
- ScopedMockTransaction transaction(kETagGET_Transaction);
- int64 received_bytes = RunTransactionAndGetReceivedBytes(cache, transaction);
- EXPECT_EQ(TransactionSize(transaction), received_bytes);
-
- transaction.load_flags = net::LOAD_VALIDATE_CACHE;
- transaction.handler = ETagGet_ConditionalRequest_Handler;
- received_bytes = RunTransactionAndGetReceivedBytes(cache, transaction);
- EXPECT_EQ(TransactionSize(transaction), received_bytes);
-}
-
-TEST(HttpCache, ReceivedBytesConditionalRequest200) {
- MockHttpCache cache;
-
- MockTransaction transaction(kTypicalGET_Transaction);
- transaction.request_headers = "Foo: bar\r\n";
- transaction.response_headers =
- "Date: Wed, 28 Nov 2007 09:40:09 GMT\n"
- "Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
- "Etag: \"foopy\"\n"
- "Cache-Control: max-age=0\n"
- "Vary: Foo\n";
- AddMockTransaction(&transaction);
- int64 received_bytes = RunTransactionAndGetReceivedBytes(cache, transaction);
- EXPECT_EQ(TransactionSize(transaction), received_bytes);
-
- RevalidationServer server;
- transaction.handler = server.Handler;
- transaction.request_headers = "Foo: none\r\n";
- received_bytes = RunTransactionAndGetReceivedBytes(cache, transaction);
- EXPECT_EQ(TransactionSize(transaction), received_bytes);
-
- RemoveMockTransaction(&transaction);
-}
-
-TEST(HttpCache, ReceivedBytesRange) {
- MockHttpCache cache;
- AddMockTransaction(&kRangeGET_TransactionOK);
- MockTransaction transaction(kRangeGET_TransactionOK);
-
- // Read bytes 40-49 from the network.
- int64 received_bytes = RunTransactionAndGetReceivedBytes(cache, transaction);
- int64 range_response_size = TransactionSize(transaction);
- EXPECT_EQ(range_response_size, received_bytes);
-
- // Read bytes 40-49 from the cache.
- received_bytes = RunTransactionAndGetReceivedBytes(cache, transaction);
- EXPECT_EQ(0, received_bytes);
- base::MessageLoop::current()->RunUntilIdle();
-
- // Read bytes 30-39 from the network.
- transaction.request_headers = "Range: bytes = 30-39\r\n" EXTRA_HEADER;
- transaction.data = "rg: 30-39 ";
- received_bytes = RunTransactionAndGetReceivedBytes(cache, transaction);
- EXPECT_EQ(range_response_size, received_bytes);
- base::MessageLoop::current()->RunUntilIdle();
-
- // Read bytes 20-29 and 50-59 from the network, bytes 30-49 from the cache.
- transaction.request_headers = "Range: bytes = 20-59\r\n" EXTRA_HEADER;
- transaction.data = "rg: 20-29 rg: 30-39 rg: 40-49 rg: 50-59 ";
- received_bytes = RunTransactionAndGetReceivedBytes(cache, transaction);
- EXPECT_EQ(range_response_size * 2, received_bytes);
-
- RemoveMockTransaction(&kRangeGET_TransactionOK);
-}
-
-class HttpCachePrefetchValidationTest : public ::testing::Test {
- protected:
- static const int kMaxAgeSecs = 100;
- static const int kRequireValidationSecs = kMaxAgeSecs + 1;
-
- HttpCachePrefetchValidationTest() : transaction_(kSimpleGET_Transaction) {
- DCHECK_LT(kMaxAgeSecs, prefetch_reuse_mins() * net::kNumSecondsPerMinute);
-
- clock_ = new base::SimpleTestClock();
- cache_.http_cache()->SetClockForTesting(make_scoped_ptr(clock_));
- cache_.network_layer()->SetClock(clock_);
-
- transaction_.response_headers = "Cache-Control: max-age=100\n";
- }
-
- bool TransactionRequiredNetwork(int load_flags) {
- int pre_transaction_count = transaction_count();
- transaction_.load_flags = load_flags;
- RunTransactionTest(cache_.http_cache(), transaction_);
- return pre_transaction_count != transaction_count();
- }
-
- void AdvanceTime(int seconds) {
- clock_->Advance(base::TimeDelta::FromSeconds(seconds));
- }
-
- int prefetch_reuse_mins() { return net::HttpCache::kPrefetchReuseMins; }
-
- // How many times this test has sent requests to the (fake) origin
- // server. Every test case needs to make at least one request to initialise
- // the cache.
- int transaction_count() {
- return cache_.network_layer()->transaction_count();
- }
-
- MockHttpCache cache_;
- ScopedMockTransaction transaction_;
- std::string response_headers_;
- base::SimpleTestClock* clock_;
-};
-
-TEST_F(HttpCachePrefetchValidationTest, SkipValidationShortlyAfterPrefetch) {
- EXPECT_TRUE(TransactionRequiredNetwork(net::LOAD_PREFETCH));
- AdvanceTime(kRequireValidationSecs);
- EXPECT_FALSE(TransactionRequiredNetwork(net::LOAD_NORMAL));
-}
-
-TEST_F(HttpCachePrefetchValidationTest, ValidateLongAfterPrefetch) {
- EXPECT_TRUE(TransactionRequiredNetwork(net::LOAD_PREFETCH));
- AdvanceTime(prefetch_reuse_mins() * net::kNumSecondsPerMinute);
- EXPECT_TRUE(TransactionRequiredNetwork(net::LOAD_NORMAL));
-}
-
-TEST_F(HttpCachePrefetchValidationTest, SkipValidationOnceOnly) {
- EXPECT_TRUE(TransactionRequiredNetwork(net::LOAD_PREFETCH));
- AdvanceTime(kRequireValidationSecs);
- EXPECT_FALSE(TransactionRequiredNetwork(net::LOAD_NORMAL));
- EXPECT_TRUE(TransactionRequiredNetwork(net::LOAD_NORMAL));
-}
-
-TEST_F(HttpCachePrefetchValidationTest, SkipValidationOnceReadOnly) {
- EXPECT_TRUE(TransactionRequiredNetwork(net::LOAD_PREFETCH));
- AdvanceTime(kRequireValidationSecs);
- EXPECT_FALSE(TransactionRequiredNetwork(net::LOAD_ONLY_FROM_CACHE));
- EXPECT_TRUE(TransactionRequiredNetwork(net::LOAD_NORMAL));
-}
-
-TEST_F(HttpCachePrefetchValidationTest, BypassCacheOverwritesPrefetch) {
- EXPECT_TRUE(TransactionRequiredNetwork(net::LOAD_PREFETCH));
- AdvanceTime(kRequireValidationSecs);
- EXPECT_TRUE(TransactionRequiredNetwork(net::LOAD_BYPASS_CACHE));
- AdvanceTime(kRequireValidationSecs);
- EXPECT_TRUE(TransactionRequiredNetwork(net::LOAD_NORMAL));
-}
-
-TEST_F(HttpCachePrefetchValidationTest,
- SkipValidationOnExistingEntryThatNeedsValidation) {
- EXPECT_TRUE(TransactionRequiredNetwork(net::LOAD_NORMAL));
- AdvanceTime(kRequireValidationSecs);
- EXPECT_TRUE(TransactionRequiredNetwork(net::LOAD_PREFETCH));
- AdvanceTime(kRequireValidationSecs);
- EXPECT_FALSE(TransactionRequiredNetwork(net::LOAD_NORMAL));
- EXPECT_TRUE(TransactionRequiredNetwork(net::LOAD_NORMAL));
-}
-
-TEST_F(HttpCachePrefetchValidationTest,
- SkipValidationOnExistingEntryThatDoesNotNeedValidation) {
- EXPECT_TRUE(TransactionRequiredNetwork(net::LOAD_NORMAL));
- EXPECT_FALSE(TransactionRequiredNetwork(net::LOAD_PREFETCH));
- AdvanceTime(kRequireValidationSecs);
- EXPECT_FALSE(TransactionRequiredNetwork(net::LOAD_NORMAL));
- EXPECT_TRUE(TransactionRequiredNetwork(net::LOAD_NORMAL));
-}
-
-TEST_F(HttpCachePrefetchValidationTest, PrefetchMultipleTimes) {
- EXPECT_TRUE(TransactionRequiredNetwork(net::LOAD_PREFETCH));
- EXPECT_FALSE(TransactionRequiredNetwork(net::LOAD_PREFETCH));
- AdvanceTime(kRequireValidationSecs);
- EXPECT_FALSE(TransactionRequiredNetwork(net::LOAD_NORMAL));
-}
-
-TEST_F(HttpCachePrefetchValidationTest, ValidateOnDelayedSecondPrefetch) {
- EXPECT_TRUE(TransactionRequiredNetwork(net::LOAD_PREFETCH));
- AdvanceTime(kRequireValidationSecs);
- EXPECT_TRUE(TransactionRequiredNetwork(net::LOAD_PREFETCH));
- AdvanceTime(kRequireValidationSecs);
- EXPECT_FALSE(TransactionRequiredNetwork(net::LOAD_NORMAL));
-}
-
-// Framework for tests of stale-while-revalidate related functionality. With
-// the default settings (age=3601,stale-while-revalidate=7200,max-age=3600) it
-// will trigger the stale-while-revalidate asynchronous revalidation. Setting
-// |age_| to < 3600 will prevent any revalidation, and |age_| > 10800 will cause
-// synchronous revalidation.
-class HttpCacheStaleWhileRevalidateTest : public ::testing::Test {
- protected:
- HttpCacheStaleWhileRevalidateTest()
- : transaction_(kSimpleGET_Transaction),
- age_(3601),
- stale_while_revalidate_(7200),
- validator_("Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT") {
- cache_.http_cache()->set_use_stale_while_revalidate_for_testing(true);
- }
-
- // RunTransactionTest() with the arguments from this fixture.
- void RunFixtureTransactionTest() {
- std::string response_headers = base::StringPrintf(
- "%s\n"
- "Age: %d\n"
- "Cache-Control: max-age=3600,stale-while-revalidate=%d\n",
- validator_.c_str(),
- age_,
- stale_while_revalidate_);
- transaction_.response_headers = response_headers.c_str();
- RunTransactionTest(cache_.http_cache(), transaction_);
- transaction_.response_headers = "";
- }
-
- // How many times this test has sent requests to the (fake) origin
- // server. Every test case needs to make at least one request to initialise
- // the cache.
- int transaction_count() {
- return cache_.network_layer()->transaction_count();
- }
-
- // How many times an existing cache entry was opened during the test case.
- int open_count() { return cache_.disk_cache()->open_count(); }
-
- MockHttpCache cache_;
- ScopedMockTransaction transaction_;
- int age_;
- int stale_while_revalidate_;
- std::string validator_;
-};
-
-static void CheckResourceFreshnessHeader(const net::HttpRequestInfo* request,
- std::string* response_status,
- std::string* response_headers,
- std::string* response_data) {
- std::string value;
- EXPECT_TRUE(request->extra_headers.GetHeader("Resource-Freshness", &value));
- EXPECT_EQ("max-age=3600,stale-while-revalidate=7200,age=10801", value);
-}
-
-// Verify that the Resource-Freshness header is sent on a revalidation if the
-// stale-while-revalidate directive was on the response.
-TEST_F(HttpCacheStaleWhileRevalidateTest, ResourceFreshnessHeaderSent) {
- age_ = 10801; // Outside the stale-while-revalidate window.
-
- // Write to the cache.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(1, transaction_count());
-
- // Send the request again and check that Resource-Freshness header is added.
- transaction_.handler = CheckResourceFreshnessHeader;
-
- RunFixtureTransactionTest();
-
- EXPECT_EQ(2, transaction_count());
-}
-
-static void CheckResourceFreshnessAbsent(const net::HttpRequestInfo* request,
- std::string* response_status,
- std::string* response_headers,
- std::string* response_data) {
- EXPECT_FALSE(request->extra_headers.HasHeader("Resource-Freshness"));
-}
-
-// Verify that the Resource-Freshness header is not sent when
-// stale-while-revalidate is 0.
-TEST_F(HttpCacheStaleWhileRevalidateTest, ResourceFreshnessHeaderNotSent) {
- age_ = 10801;
- stale_while_revalidate_ = 0;
-
- // Write to the cache.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(1, transaction_count());
-
- // Send the request again and check that Resource-Freshness header is absent.
- transaction_.handler = CheckResourceFreshnessAbsent;
-
- RunFixtureTransactionTest();
-
- EXPECT_EQ(2, transaction_count());
-}
-
-// Verify that when stale-while-revalidate applies the response is read from
-// cache.
-TEST_F(HttpCacheStaleWhileRevalidateTest, ReadFromCache) {
- // Write to the cache.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(0, open_count());
- EXPECT_EQ(1, transaction_count());
-
- // Read back from the cache.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(1, open_count());
- EXPECT_EQ(1, transaction_count());
-}
-
-// Verify that when stale-while-revalidate applies an asynchronous request is
-// sent.
-TEST_F(HttpCacheStaleWhileRevalidateTest, AsyncRequestSent) {
- // Write to the cache.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(1, transaction_count());
-
- // Read back from the cache.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(1, transaction_count());
-
- // Let the async request execute.
- base::RunLoop().RunUntilIdle();
- EXPECT_EQ(2, transaction_count());
-}
-
-// Verify that tearing down the HttpCache with an async revalidation in progress
-// does not break anything (this test is most likely to find problems when run
-// with a memory checker such as AddressSanitizer).
-TEST_F(HttpCacheStaleWhileRevalidateTest, AsyncTearDown) {
- // Write to the cache.
- RunFixtureTransactionTest();
-
- // Read back from the cache.
- RunFixtureTransactionTest();
-}
-
-static void CheckIfModifiedSinceHeader(const net::HttpRequestInfo* request,
- std::string* response_status,
- std::string* response_headers,
- std::string* response_data) {
- std::string value;
- EXPECT_TRUE(request->extra_headers.GetHeader("If-Modified-Since", &value));
- EXPECT_EQ("Sat, 18 Apr 2007 01:10:43 GMT", value);
-}
-
-// Verify that the async revalidation contains an If-Modified-Since header.
-TEST_F(HttpCacheStaleWhileRevalidateTest, AsyncRequestIfModifiedSince) {
- // Write to the cache.
- RunFixtureTransactionTest();
-
- transaction_.handler = CheckIfModifiedSinceHeader;
-
- // Read back from the cache.
- RunFixtureTransactionTest();
-}
-
-static void CheckIfNoneMatchHeader(const net::HttpRequestInfo* request,
- std::string* response_status,
- std::string* response_headers,
- std::string* response_data) {
- std::string value;
- EXPECT_TRUE(request->extra_headers.GetHeader("If-None-Match", &value));
- EXPECT_EQ("\"40a1-1320-4f6adefa22a40\"", value);
-}
-
-// If the response had ETag rather than Last-Modified, then that is used to
-// conditionalise the response.
-TEST_F(HttpCacheStaleWhileRevalidateTest, AsyncRequestIfNoneMatch) {
- validator_ = "Etag: \"40a1-1320-4f6adefa22a40\"";
-
- // Write to the cache.
- RunFixtureTransactionTest();
-
- transaction_.handler = CheckIfNoneMatchHeader;
-
- // Read back from the cache.
- RunFixtureTransactionTest();
-}
-
-static void CheckResourceFreshnessHeaderPresent(
- const net::HttpRequestInfo* request,
- std::string* response_status,
- std::string* response_headers,
- std::string* response_data) {
- EXPECT_TRUE(request->extra_headers.HasHeader("Resource-Freshness"));
-}
-
-TEST_F(HttpCacheStaleWhileRevalidateTest, AsyncRequestHasResourceFreshness) {
- // Write to the cache.
- RunFixtureTransactionTest();
-
- transaction_.handler = CheckResourceFreshnessHeaderPresent;
-
- // Read back from the cache.
- RunFixtureTransactionTest();
-}
-
-// Verify that when age > max-age + stale-while-revalidate stale results are
-// not returned.
-TEST_F(HttpCacheStaleWhileRevalidateTest, NotAppliedIfTooStale) {
- age_ = 10801;
-
- // Write to the cache.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(0, open_count());
- EXPECT_EQ(1, transaction_count());
-
- // Reading back reads from the network.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(1, open_count());
- EXPECT_EQ(2, transaction_count());
-}
-
-// HEAD requests should be able to take advantage of stale-while-revalidate.
-TEST_F(HttpCacheStaleWhileRevalidateTest, WorksForHeadMethod) {
- // Write to the cache. This has to be a GET request; HEAD requests don't
- // create new cache entries.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(0, open_count());
- EXPECT_EQ(1, transaction_count());
-
- // Read back from the cache, and trigger an asynchronous HEAD request.
- transaction_.method = "HEAD";
- transaction_.data = "";
-
- RunFixtureTransactionTest();
-
- EXPECT_EQ(1, open_count());
- EXPECT_EQ(1, transaction_count());
-
- // Let the network request proceed.
- base::RunLoop().RunUntilIdle();
-
- EXPECT_EQ(2, transaction_count());
-}
-
-// POST requests should not use stale-while-revalidate.
-TEST_F(HttpCacheStaleWhileRevalidateTest, NotAppliedToPost) {
- transaction_ = ScopedMockTransaction(kSimplePOST_Transaction);
-
- // Write to the cache.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(0, open_count());
- EXPECT_EQ(1, transaction_count());
-
- // Reading back reads from the network.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(0, open_count());
- EXPECT_EQ(2, transaction_count());
-}
-
-static void CheckUrlMatches(const net::HttpRequestInfo* request,
- std::string* response_status,
- std::string* response_headers,
- std::string* response_data) {
- EXPECT_EQ("http://www.google.com/", request->url.spec());
-}
-
-// Async revalidation is issued to the original URL.
-TEST_F(HttpCacheStaleWhileRevalidateTest, AsyncRequestUrlMatches) {
- transaction_.url = "http://www.google.com/";
- // Write to the cache.
- RunFixtureTransactionTest();
-
- // Read back from the cache.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(1, transaction_count());
-
- transaction_.handler = CheckUrlMatches;
-
- // Let the async request execute and perform the check.
- base::RunLoop().RunUntilIdle();
- EXPECT_EQ(2, transaction_count());
-}
-
-class SyncLoadFlagTest : public HttpCacheStaleWhileRevalidateTest,
- public ::testing::WithParamInterface<int> {};
-
-// Flags which should always cause the request to be synchronous.
-TEST_P(SyncLoadFlagTest, MustBeSynchronous) {
- transaction_.load_flags |= GetParam();
- // Write to the cache.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(1, transaction_count());
-
- // Reading back reads from the network.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(2, transaction_count());
-}
-
-INSTANTIATE_TEST_CASE_P(HttpCacheStaleWhileRevalidate,
- SyncLoadFlagTest,
- ::testing::Values(net::LOAD_VALIDATE_CACHE,
- net::LOAD_BYPASS_CACHE,
- net::LOAD_DISABLE_CACHE));
-
-TEST_F(HttpCacheStaleWhileRevalidateTest,
- PreferringCacheDoesNotTriggerAsyncRequest) {
- transaction_.load_flags |= net::LOAD_PREFERRING_CACHE;
- // Write to the cache.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(1, transaction_count());
-
- // Reading back reads from the cache.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(1, transaction_count());
-
- // If there was an async transaction created, it would run now.
- base::RunLoop().RunUntilIdle();
-
- // There was no async transaction.
- EXPECT_EQ(1, transaction_count());
-}
-
-TEST_F(HttpCacheStaleWhileRevalidateTest, NotUsedWhenDisabled) {
- cache_.http_cache()->set_use_stale_while_revalidate_for_testing(false);
- // Write to the cache.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(1, transaction_count());
-
- // A synchronous revalidation is performed.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(2, transaction_count());
-}
-
-TEST_F(HttpCacheStaleWhileRevalidateTest,
- OnlyFromCacheDoesNotTriggerAsyncRequest) {
- transaction_.load_flags |= net::LOAD_ONLY_FROM_CACHE;
- transaction_.return_code = net::ERR_CACHE_MISS;
-
- // Writing to the cache should fail, because we are avoiding the network.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(0, transaction_count());
-
- base::RunLoop().RunUntilIdle();
-
- // Still nothing.
- EXPECT_EQ(0, transaction_count());
-}
-
-// A certificate error during an asynchronous fetch should cause the next fetch
-// to proceed synchronously.
-// TODO(ricea): In future, only certificate errors which require user
-// interaction should fail the asynchronous revalidation, and they should cause
-// the next revalidation to be synchronous rather than requiring a total
-// refetch. This test will need to be updated appropriately.
-TEST_F(HttpCacheStaleWhileRevalidateTest, CertificateErrorCausesRefetch) {
- // Write to the cache.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(1, transaction_count());
-
- // Now read back. RunTransactionTestBase() expects to receive the network
- // error back from the HttpCache::Transaction, but since the cache request
- // will return OK we need to duplicate some of its implementation here.
- transaction_.return_code = net::ERR_SSL_CLIENT_AUTH_CERT_NEEDED;
- 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());
-
- MockHttpRequest request(transaction_);
- rv = trans->Start(&request, callback.callback(), net::BoundNetLog());
- ASSERT_EQ(net::ERR_IO_PENDING, rv);
- ASSERT_EQ(net::OK, callback.WaitForResult());
- ReadAndVerifyTransaction(trans.get(), transaction_);
-
- EXPECT_EQ(1, transaction_count());
-
- // Allow the asynchronous fetch to run.
- base::RunLoop().RunUntilIdle();
-
- EXPECT_EQ(2, transaction_count());
-
- // Now run the transaction again. It should run synchronously.
- transaction_.return_code = net::OK;
- RunFixtureTransactionTest();
-
- EXPECT_EQ(3, transaction_count());
-}
-
-// Ensure that the response cached by the asynchronous request is not truncated,
-// even if the server is slow.
-TEST_F(HttpCacheStaleWhileRevalidateTest, EntireResponseCached) {
- transaction_.test_mode = TEST_MODE_SLOW_READ;
- // Write to the cache.
- RunFixtureTransactionTest();
-
- // Read back from the cache.
- RunFixtureTransactionTest();
-
- // Let the async request execute.
- base::RunLoop().RunUntilIdle();
-
- // The cache entry should still be complete.
- transaction_.load_flags = net::LOAD_ONLY_FROM_CACHE;
- RunFixtureTransactionTest();
-}
-
-// Verify that there are no race conditions in the completely synchronous case.
-TEST_F(HttpCacheStaleWhileRevalidateTest, SynchronousCaseWorks) {
- transaction_.test_mode = TEST_MODE_SYNC_ALL;
- // Write to the cache.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(1, transaction_count());
-
- // Read back from the cache.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(1, transaction_count());
-
- // Let the async request execute.
- base::RunLoop().RunUntilIdle();
- EXPECT_EQ(2, transaction_count());
-}
-
-static void CheckLoadFlagsAsyncRevalidation(const net::HttpRequestInfo* request,
- std::string* response_status,
- std::string* response_headers,
- std::string* response_data) {
- EXPECT_EQ(net::LOAD_ASYNC_REVALIDATION, request->load_flags);
-}
-
-// Check that the load flags on the async request are the same as the load flags
-// on the original request, plus LOAD_ASYNC_REVALIDATION.
-TEST_F(HttpCacheStaleWhileRevalidateTest, LoadFlagsAsyncRevalidation) {
- transaction_.load_flags = net::LOAD_NORMAL;
- // Write to the cache.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(1, transaction_count());
-
- // Read back from the cache.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(1, transaction_count());
-
- transaction_.handler = CheckLoadFlagsAsyncRevalidation;
- // Let the async request execute.
- base::RunLoop().RunUntilIdle();
- EXPECT_EQ(2, transaction_count());
-}
-
-static void SimpleMockAuthHandler(const net::HttpRequestInfo* request,
- std::string* response_status,
- std::string* response_headers,
- std::string* response_data) {
- if (request->extra_headers.HasHeader("X-Require-Mock-Auth") &&
- !request->extra_headers.HasHeader("Authorization")) {
- response_status->assign("HTTP/1.1 401 Unauthorized");
- response_headers->assign("WWW-Authenticate: Basic realm=\"mars\"\n");
- return;
- }
- response_status->assign("HTTP/1.1 200 OK");
-}
-
-TEST_F(HttpCacheStaleWhileRevalidateTest, RestartForAuth) {
- // Write to the cache.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(1, transaction_count());
-
- // Now make the transaction require auth.
- transaction_.request_headers = "X-Require-Mock-Auth: dummy\r\n\r\n";
- transaction_.handler = SimpleMockAuthHandler;
-
- // Read back from the cache.
- RunFixtureTransactionTest();
-
- EXPECT_EQ(1, transaction_count());
-
- // Let the async request execute.
- base::RunLoop().RunUntilIdle();
-
- EXPECT_EQ(2, transaction_count());
-}
-
-// Tests that we allow multiple simultaneous, non-overlapping transactions to
-// take place on a sparse entry.
-TEST(HttpCache, RangeGET_MultipleRequests) {
- MockHttpCache cache;
-
- // Create a transaction for bytes 0-9.
- MockHttpRequest request(kRangeGET_TransactionOK);
- MockTransaction transaction(kRangeGET_TransactionOK);
- transaction.request_headers = "Range: bytes = 0-9\r\n" EXTRA_HEADER;
- transaction.data = "rg: 00-09 ";
- AddMockTransaction(&transaction);
-
- 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());
-
- // Start our transaction.
- trans->Start(&request, callback.callback(), net::BoundNetLog());
-
- // A second transaction on a different part of the file (the default
- // kRangeGET_TransactionOK requests 40-49) should not be blocked by
- // the already pending transaction.
- RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
-
- // Let the first transaction complete.
- callback.WaitForResult();
-
- RemoveMockTransaction(&transaction);
-}
-
-// Makes sure that a request stops using the cache when the response headers
-// with "Cache-Control: no-store" arrives. That means that another request for
-// the same URL can be processed before the response body of the original
-// request arrives.
-TEST(HttpCache, NoStoreResponseShouldNotBlockFollowingRequests) {
- MockHttpCache cache;
- ScopedMockTransaction mock_transaction(kSimpleGET_Transaction);
- mock_transaction.response_headers = "Cache-Control: no-store\n";
- MockHttpRequest request(mock_transaction);
-
- scoped_ptr<Context> first(new Context);
- first->result = cache.CreateTransaction(&first->trans);
- ASSERT_EQ(net::OK, first->result);
- EXPECT_EQ(net::LOAD_STATE_IDLE, first->trans->GetLoadState());
- first->result = first->trans->Start(
- &request, first->callback.callback(), net::BoundNetLog());
- EXPECT_EQ(net::LOAD_STATE_WAITING_FOR_CACHE, first->trans->GetLoadState());
-
- base::MessageLoop::current()->RunUntilIdle();
- EXPECT_EQ(net::LOAD_STATE_IDLE, first->trans->GetLoadState());
- ASSERT_TRUE(first->trans->GetResponseInfo());
- EXPECT_TRUE(first->trans->GetResponseInfo()->headers->HasHeaderValue(
- "Cache-Control", "no-store"));
- // Here we have read the response header but not read the response body yet.
-
- // Let us create the second (read) transaction.
- scoped_ptr<Context> second(new Context);
- second->result = cache.CreateTransaction(&second->trans);
- ASSERT_EQ(net::OK, second->result);
- EXPECT_EQ(net::LOAD_STATE_IDLE, second->trans->GetLoadState());
- second->result = second->trans->Start(
- &request, second->callback.callback(), net::BoundNetLog());
-
- // Here the second transaction proceeds without reading the first body.
- EXPECT_EQ(net::LOAD_STATE_WAITING_FOR_CACHE, second->trans->GetLoadState());
- base::MessageLoop::current()->RunUntilIdle();
- EXPECT_EQ(net::LOAD_STATE_IDLE, second->trans->GetLoadState());
- ASSERT_TRUE(second->trans->GetResponseInfo());
- EXPECT_TRUE(second->trans->GetResponseInfo()->headers->HasHeaderValue(
- "Cache-Control", "no-store"));
- ReadAndVerifyTransaction(second->trans.get(), kSimpleGET_Transaction);
-}
« no previous file with comments | « net/http/http_cache_transaction.cc ('k') | net/http/http_chunked_decoder.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698