15821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Copyright (c) 2012 The Chromium Authors. All rights reserved. 25821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Use of this source code is governed by a BSD-style license that can be 35821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// found in the LICENSE file. 45821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 55821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "base/basictypes.h" 65821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "base/bind.h" 75821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "base/bind_helpers.h" 85821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "base/file_util.h" 95e3f23d412006dc4db4e659864679f29341e113fTorne (Richard Coles)#include "base/strings/string_util.h" 105e3f23d412006dc4db4e659864679f29341e113fTorne (Richard Coles)#include "base/strings/stringprintf.h" 115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "base/threading/platform_thread.h" 12eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#include "base/timer/timer.h" 135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "net/base/completion_callback.h" 145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "net/base/io_buffer.h" 155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "net/base/net_errors.h" 165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "net/base/test_completion_callback.h" 175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "net/disk_cache/backend_impl.h" 185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "net/disk_cache/disk_cache_test_base.h" 195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "net/disk_cache/disk_cache_test_util.h" 205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "net/disk_cache/entry_impl.h" 215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "net/disk_cache/mem_entry_impl.h" 22c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)#include "net/disk_cache/simple/simple_entry_format.h" 23c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)#include "net/disk_cache/simple/simple_entry_impl.h" 247dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch#include "net/disk_cache/simple/simple_test_util.h" 25c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)#include "net/disk_cache/simple/simple_util.h" 265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "testing/gtest/include/gtest/gtest.h" 275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)using base::Time; 29bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdochusing disk_cache::ScopedEntryPtr; 305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Tests that can run with different types of caches. 325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class DiskCacheEntryTest : public DiskCacheTestWithCache { 335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) public: 345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void InternalSyncIOBackground(disk_cache::Entry* entry); 355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void ExternalSyncIOBackground(disk_cache::Entry* entry); 365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) protected: 385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void InternalSyncIO(); 395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void InternalAsyncIO(); 405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void ExternalSyncIO(); 415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void ExternalAsyncIO(); 425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void ReleaseBuffer(); 435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void StreamAccess(); 445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void GetKey(); 455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void GetTimes(); 465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void GrowData(); 475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void TruncateData(); 485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void ZeroLengthIO(); 495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void Buffering(); 50c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) void SizeAtCreate(); 515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void SizeChanges(); 525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void ReuseEntry(int size); 535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void InvalidData(); 54c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) void ReadWriteDestroyBuffer(); 555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void DoomNormalEntry(); 565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void DoomEntryNextToOpenEntry(); 575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void DoomedEntry(); 585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void BasicSparseIO(); 595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void HugeSparseIO(); 605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void GetAvailableRange(); 615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void CouldBeSparse(); 625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void UpdateSparseEntry(); 635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void DoomSparseEntry(); 645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void PartialSparseEntry(); 65868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) bool SimpleCacheMakeBadChecksumEntry(const char* key, int* data_size); 665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)}; 675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// This part of the test runs on the background thread. 695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::InternalSyncIOBackground(disk_cache::Entry* entry) { 705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize1 = 10; 715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1)); 725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer1->data(), kSize1, false); 73868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ( 74868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 75868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->ReadData(0, 0, buffer1.get(), kSize1, net::CompletionCallback())); 765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::strlcpy(buffer1->data(), "the data", kSize1); 77868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(10, 78868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->WriteData( 79868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 0, buffer1.get(), kSize1, net::CompletionCallback(), false)); 805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) memset(buffer1->data(), 0, kSize1); 81868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ( 82868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 10, 83868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->ReadData(0, 0, buffer1.get(), kSize1, net::CompletionCallback())); 845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_STREQ("the data", buffer1->data()); 855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize2 = 5000; 875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize3 = 10000; 885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2)); 895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer3(new net::IOBuffer(kSize3)); 905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) memset(buffer3->data(), 0, kSize3); 915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer2->data(), kSize2, false); 925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::strlcpy(buffer2->data(), "The really big data goes here", kSize2); 93868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ( 94868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 5000, 95868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->WriteData( 96868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 1500, buffer2.get(), kSize2, net::CompletionCallback(), false)); 975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) memset(buffer2->data(), 0, kSize2); 98868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(4989, 99868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->ReadData( 100868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 1511, buffer2.get(), kSize2, net::CompletionCallback())); 1015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_STREQ("big data goes here", buffer2->data()); 102868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ( 103868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 5000, 104868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->ReadData(1, 0, buffer2.get(), kSize2, net::CompletionCallback())); 1055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 1500)); 106868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(1500, 107868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->ReadData( 108868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 5000, buffer2.get(), kSize2, net::CompletionCallback())); 109868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 110868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(0, 111868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->ReadData( 112868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 6500, buffer2.get(), kSize2, net::CompletionCallback())); 113868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ( 114868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 6500, 115868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->ReadData(1, 0, buffer3.get(), kSize3, net::CompletionCallback())); 116868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(8192, 117868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->WriteData( 118868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 0, buffer3.get(), 8192, net::CompletionCallback(), false)); 119868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ( 120868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 8192, 121868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->ReadData(1, 0, buffer3.get(), kSize3, net::CompletionCallback())); 1225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(8192, entry->GetDataSize(1)); 1235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // We need to delete the memory buffer on this thread. 1255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, entry->WriteData( 1265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 0, 0, NULL, 0, net::CompletionCallback(), true)); 1275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, entry->WriteData( 1285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1, 0, NULL, 0, net::CompletionCallback(), true)); 1295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 1305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// We need to support synchronous IO even though it is not a supported operation 1325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// from the point of view of the disk cache's public interface, because we use 1335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// it internally, not just by a few tests, but as part of the implementation 1345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// (see sparse_control.cc, for example). 1355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::InternalSyncIO() { 1365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry = NULL; 1375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry("the first key", &entry)); 1385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_TRUE(NULL != entry); 1395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // The bulk of the test runs from within the callback, on the cache thread. 1415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) RunTaskForTest(base::Bind(&DiskCacheEntryTest::InternalSyncIOBackground, 1425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::Unretained(this), 1435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry)); 1445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Doom(); 1475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 1485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) FlushQueueForTest(); 1495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, cache_->GetEntryCount()); 1505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 1515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, InternalSyncIO) { 1535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 1545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InternalSyncIO(); 1555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 1565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlyInternalSyncIO) { 1585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 1595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 1605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InternalSyncIO(); 1615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 1625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::InternalAsyncIO() { 1645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry = NULL; 1655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry("the first key", &entry)); 1665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_TRUE(NULL != entry); 1675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Avoid using internal buffers for the test. We have to write something to 1695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // the entry and close it so that we flush the internal buffer to disk. After 1705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // that, IO operations will be really hitting the disk. We don't care about 1715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // the content, so just extending the entry is enough (all extensions zero- 1725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // fill any holes). 1735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, WriteData(entry, 0, 15 * 1024, NULL, 0, false)); 1745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, WriteData(entry, 1, 15 * 1024, NULL, 0, false)); 1755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 1765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry("the first key", &entry)); 1775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) MessageLoopHelper helper; 1795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Let's verify that each IO goes to the right callback object. 1805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CallbackTest callback1(&helper, false); 1815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CallbackTest callback2(&helper, false); 1825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CallbackTest callback3(&helper, false); 1835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CallbackTest callback4(&helper, false); 1845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CallbackTest callback5(&helper, false); 1855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CallbackTest callback6(&helper, false); 1865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CallbackTest callback7(&helper, false); 1875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CallbackTest callback8(&helper, false); 1885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CallbackTest callback9(&helper, false); 1895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CallbackTest callback10(&helper, false); 1905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CallbackTest callback11(&helper, false); 1915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CallbackTest callback12(&helper, false); 1925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CallbackTest callback13(&helper, false); 1935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize1 = 10; 1955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize2 = 5000; 1965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize3 = 10000; 1975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1)); 1985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2)); 1995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer3(new net::IOBuffer(kSize3)); 2005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer1->data(), kSize1, false); 2015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer2->data(), kSize2, false); 2025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer3->data(), kSize3, false); 2035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 204868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(0, 205868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->ReadData( 206868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 207868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 15 * 1024, 208868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer1.get(), 209868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kSize1, 210868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback1)))); 2115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::strlcpy(buffer1->data(), "the data", kSize1); 2125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int expected = 0; 2135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int ret = entry->WriteData( 214868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 215868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 216868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer1.get(), 217868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kSize1, 218868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback2)), 219868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) false); 2205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret); 2215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (net::ERR_IO_PENDING == ret) 2225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) expected++; 2235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); 2255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) memset(buffer2->data(), 0, kSize2); 2265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ret = entry->ReadData( 227868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 228868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 229868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer2.get(), 230868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kSize1, 2315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback3))); 2325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret); 2335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (net::ERR_IO_PENDING == ret) 2345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) expected++; 2355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); 2375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_STREQ("the data", buffer2->data()); 2385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::strlcpy(buffer2->data(), "The really big data goes here", kSize2); 2405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ret = entry->WriteData( 241868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 242868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1500, 243868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer2.get(), 244868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kSize2, 245868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback4)), 246868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) true); 2475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret); 2485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (net::ERR_IO_PENDING == ret) 2495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) expected++; 2505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); 2525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) memset(buffer3->data(), 0, kSize3); 2535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ret = entry->ReadData( 254868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 255868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1511, 256868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer3.get(), 257868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kSize2, 2585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback5))); 2595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(4989 == ret || net::ERR_IO_PENDING == ret); 2605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (net::ERR_IO_PENDING == ret) 2615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) expected++; 2625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); 2645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_STREQ("big data goes here", buffer3->data()); 2655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ret = entry->ReadData( 266868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 267868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 268868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer2.get(), 269868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kSize2, 2705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback6))); 2715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret); 2725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (net::ERR_IO_PENDING == ret) 2735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) expected++; 2745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) memset(buffer3->data(), 0, kSize3); 2765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); 2785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 1500)); 2795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ret = entry->ReadData( 280868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 281868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 5000, 282868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer2.get(), 283868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kSize2, 2845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback7))); 2855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(1500 == ret || net::ERR_IO_PENDING == ret); 2865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (net::ERR_IO_PENDING == ret) 2875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) expected++; 2885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ret = entry->ReadData( 290868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 291868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 292868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer3.get(), 293868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kSize3, 2945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback9))); 2955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(6500 == ret || net::ERR_IO_PENDING == ret); 2965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (net::ERR_IO_PENDING == ret) 2975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) expected++; 2985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ret = entry->WriteData( 300868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 301868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 302868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer3.get(), 303868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 8192, 304868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback10)), 305868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) true); 3065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(8192 == ret || net::ERR_IO_PENDING == ret); 3075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (net::ERR_IO_PENDING == ret) 3085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) expected++; 3095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); 3115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ret = entry->ReadData( 312868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 313868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 314868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer3.get(), 315868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kSize3, 3165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback11))); 3175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(8192 == ret || net::ERR_IO_PENDING == ret); 3185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (net::ERR_IO_PENDING == ret) 3195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) expected++; 3205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(8192, entry->GetDataSize(1)); 3225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ret = entry->ReadData( 324868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 325868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 326868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer1.get(), 327868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kSize1, 3285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback12))); 3295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret); 3305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (net::ERR_IO_PENDING == ret) 3315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) expected++; 3325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ret = entry->ReadData( 334868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 335868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 336868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer2.get(), 337868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kSize2, 3385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback13))); 3395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret); 3405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (net::ERR_IO_PENDING == ret) 3415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) expected++; 3425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); 3445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_FALSE(helper.callback_reused_error()); 3465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Doom(); 3485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 3495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) FlushQueueForTest(); 3505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, cache_->GetEntryCount()); 3515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 3525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, InternalAsyncIO) { 3545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 3555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InternalAsyncIO(); 3565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 3575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlyInternalAsyncIO) { 3595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 3605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 3615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InternalAsyncIO(); 3625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 3635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// This part of the test runs on the background thread. 3655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::ExternalSyncIOBackground(disk_cache::Entry* entry) { 3665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize1 = 17000; 3675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize2 = 25000; 3685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1)); 3695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2)); 3705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer1->data(), kSize1, false); 3715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer2->data(), kSize2, false); 3725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::strlcpy(buffer1->data(), "the data", kSize1); 373868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(17000, 374868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->WriteData( 375868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 0, buffer1.get(), kSize1, net::CompletionCallback(), false)); 3765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) memset(buffer1->data(), 0, kSize1); 377868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ( 378868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 17000, 379868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->ReadData(0, 0, buffer1.get(), kSize1, net::CompletionCallback())); 3805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_STREQ("the data", buffer1->data()); 3815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::strlcpy(buffer2->data(), "The really big data goes here", kSize2); 383868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ( 384868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 25000, 385868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->WriteData( 386868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 10000, buffer2.get(), kSize2, net::CompletionCallback(), false)); 3875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) memset(buffer2->data(), 0, kSize2); 388868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(24989, 389868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->ReadData( 390868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 10011, buffer2.get(), kSize2, net::CompletionCallback())); 3915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_STREQ("big data goes here", buffer2->data()); 392868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ( 393868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 25000, 394868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->ReadData(1, 0, buffer2.get(), kSize2, net::CompletionCallback())); 3955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, memcmp(buffer2->data(), buffer2->data(), 10000)); 396868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(5000, 397868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->ReadData( 398868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 30000, buffer2.get(), kSize2, net::CompletionCallback())); 399868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 400868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(0, 401868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->ReadData( 402868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 35000, buffer2.get(), kSize2, net::CompletionCallback())); 403868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ( 404868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 17000, 405868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->ReadData(1, 0, buffer1.get(), kSize1, net::CompletionCallback())); 406868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ( 407868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 17000, 408868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->WriteData( 409868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 20000, buffer1.get(), kSize1, net::CompletionCallback(), false)); 4105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(37000, entry->GetDataSize(1)); 4115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // We need to delete the memory buffer on this thread. 4135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, entry->WriteData( 4145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 0, 0, NULL, 0, net::CompletionCallback(), true)); 4155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, entry->WriteData( 4165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1, 0, NULL, 0, net::CompletionCallback(), true)); 4175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 4185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::ExternalSyncIO() { 4205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 4215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry("the first key", &entry)); 4225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // The bulk of the test runs from within the callback, on the cache thread. 4245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) RunTaskForTest(base::Bind(&DiskCacheEntryTest::ExternalSyncIOBackground, 4255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::Unretained(this), 4265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry)); 4275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Doom(); 4295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 4305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) FlushQueueForTest(); 4315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, cache_->GetEntryCount()); 4325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 4335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, ExternalSyncIO) { 4355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 4365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ExternalSyncIO(); 4375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 4385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, ExternalSyncIONoBuffer) { 4405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 4415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) cache_impl_->SetFlags(disk_cache::kNoBuffering); 4425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ExternalSyncIO(); 4435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 4445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlyExternalSyncIO) { 4465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 4475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 4485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ExternalSyncIO(); 4495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 4505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::ExternalAsyncIO() { 4525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 4535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry("the first key", &entry)); 4545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int expected = 0; 4565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) MessageLoopHelper helper; 4585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Let's verify that each IO goes to the right callback object. 4595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CallbackTest callback1(&helper, false); 4605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CallbackTest callback2(&helper, false); 4615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CallbackTest callback3(&helper, false); 4625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CallbackTest callback4(&helper, false); 4635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CallbackTest callback5(&helper, false); 4645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CallbackTest callback6(&helper, false); 4655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CallbackTest callback7(&helper, false); 4665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CallbackTest callback8(&helper, false); 4675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CallbackTest callback9(&helper, false); 4685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize1 = 17000; 4705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize2 = 25000; 4715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize3 = 25000; 4725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1)); 4735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2)); 4745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer3(new net::IOBuffer(kSize3)); 4755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer1->data(), kSize1, false); 4765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer2->data(), kSize2, false); 4775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer3->data(), kSize3, false); 4785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::strlcpy(buffer1->data(), "the data", kSize1); 4795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int ret = entry->WriteData( 480868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 481868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 482868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer1.get(), 483868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kSize1, 484868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback1)), 485868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) false); 4865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret); 4875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (net::ERR_IO_PENDING == ret) 4885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) expected++; 4895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); 4915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) memset(buffer2->data(), 0, kSize1); 4935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ret = entry->ReadData( 494868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 495868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 496868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer2.get(), 497868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kSize1, 4985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback2))); 4995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret); 5005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (net::ERR_IO_PENDING == ret) 5015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) expected++; 5025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); 5042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) EXPECT_STREQ("the data", buffer2->data()); 5055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::strlcpy(buffer2->data(), "The really big data goes here", kSize2); 5075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ret = entry->WriteData( 508868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 509868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 10000, 510868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer2.get(), 511868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kSize2, 512868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback3)), 513868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) false); 5145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(25000 == ret || net::ERR_IO_PENDING == ret); 5155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (net::ERR_IO_PENDING == ret) 5165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) expected++; 5175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); 5195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) memset(buffer3->data(), 0, kSize3); 5215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ret = entry->ReadData( 522868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 523868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 10011, 524868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer3.get(), 525868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kSize3, 5265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback4))); 5275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(24989 == ret || net::ERR_IO_PENDING == ret); 5285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (net::ERR_IO_PENDING == ret) 5295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) expected++; 5305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); 5325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_STREQ("big data goes here", buffer3->data()); 5335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ret = entry->ReadData( 534868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 535868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 536868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer2.get(), 537868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kSize2, 5385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback5))); 5395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(25000 == ret || net::ERR_IO_PENDING == ret); 5405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (net::ERR_IO_PENDING == ret) 5415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) expected++; 5425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); 5442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) memset(buffer3->data(), 0, kSize3); 5452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) EXPECT_EQ(0, memcmp(buffer2->data(), buffer3->data(), 10000)); 5465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ret = entry->ReadData( 547868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 548868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 30000, 549868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer2.get(), 550868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kSize2, 5515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback6))); 5525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret); 5535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (net::ERR_IO_PENDING == ret) 5545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) expected++; 5555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 556868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(0, 557868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->ReadData( 558868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 559868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 35000, 560868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer2.get(), 561868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kSize2, 562868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback7)))); 5635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ret = entry->ReadData( 564868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 565868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 566868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer1.get(), 567868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kSize1, 5685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback8))); 5695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret); 5705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (net::ERR_IO_PENDING == ret) 5715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) expected++; 5725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ret = entry->WriteData( 573868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1, 574868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 20000, 575868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer3.get(), 576868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kSize1, 577868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback9)), 578868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) false); 5795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(17000 == ret || net::ERR_IO_PENDING == ret); 5805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (net::ERR_IO_PENDING == ret) 5815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) expected++; 5825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); 5845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(37000, entry->GetDataSize(1)); 5855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_FALSE(helper.callback_reused_error()); 5875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Doom(); 5895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 5905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) FlushQueueForTest(); 5915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, cache_->GetEntryCount()); 5925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 5935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, ExternalAsyncIO) { 5955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 5965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ExternalAsyncIO(); 5975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 5985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, ExternalAsyncIONoBuffer) { 6005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 6015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) cache_impl_->SetFlags(disk_cache::kNoBuffering); 6025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ExternalAsyncIO(); 6035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 6045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 6055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlyExternalAsyncIO) { 6065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 6075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 6085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ExternalAsyncIO(); 6095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 6105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 6115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Tests that IOBuffers are not referenced after IO completes. 6125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::ReleaseBuffer() { 6135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry = NULL; 6145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry("the first key", &entry)); 6155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_TRUE(NULL != entry); 6165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 6175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kBufferSize = 1024; 6185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize)); 6195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer->data(), kBufferSize, false); 6205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 621868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) net::ReleaseBufferCompletionCallback cb(buffer.get()); 622868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) int rv = 623868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->WriteData(0, 0, buffer.get(), kBufferSize, cb.callback(), false); 6245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(kBufferSize, cb.GetResult(rv)); 6255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 6265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 6275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 6285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, ReleaseBuffer) { 6295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 6305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) cache_impl_->SetFlags(disk_cache::kNoBuffering); 6315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ReleaseBuffer(); 6325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 6335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 6345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlyReleaseBuffer) { 6355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 6365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 6375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ReleaseBuffer(); 6385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 6395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 6405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::StreamAccess() { 6415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry = NULL; 6425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry("the first key", &entry)); 6435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_TRUE(NULL != entry); 6445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 6455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kBufferSize = 1024; 6465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kNumStreams = 3; 647c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) scoped_refptr<net::IOBuffer> reference_buffers[kNumStreams]; 6485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) for (int i = 0; i < kNumStreams; i++) { 649c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) reference_buffers[i] = new net::IOBuffer(kBufferSize); 650c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) CacheTestFillBuffer(reference_buffers[i]->data(), kBufferSize, false); 651c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) } 652c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kBufferSize)); 653c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) for (int i = 0; i < kNumStreams; i++) { 654868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ( 655868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kBufferSize, 656868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) WriteData(entry, i, 0, reference_buffers[i].get(), kBufferSize, false)); 657c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) memset(buffer1->data(), 0, kBufferSize); 658868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kBufferSize, ReadData(entry, i, 0, buffer1.get(), kBufferSize)); 659868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ( 660868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, memcmp(reference_buffers[i]->data(), buffer1->data(), kBufferSize)); 6615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 6625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(net::ERR_INVALID_ARGUMENT, 663868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ReadData(entry, kNumStreams, 0, buffer1.get(), kBufferSize)); 6645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 665c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 666c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Open the entry and read it in chunks, including a read past the end. 667c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry("the first key", &entry)); 668c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ASSERT_TRUE(NULL != entry); 669c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const int kReadBufferSize = 600; 670c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const int kFinalReadSize = kBufferSize - kReadBufferSize; 671c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) COMPILE_ASSERT(kFinalReadSize < kReadBufferSize, should_be_exactly_two_reads); 672c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kReadBufferSize)); 673c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) for (int i = 0; i < kNumStreams; i++) { 674c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) memset(buffer2->data(), 0, kReadBufferSize); 675868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kReadBufferSize, 676868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ReadData(entry, i, 0, buffer2.get(), kReadBufferSize)); 677868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ( 678868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 679868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) memcmp(reference_buffers[i]->data(), buffer2->data(), kReadBufferSize)); 680c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 681c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) memset(buffer2->data(), 0, kReadBufferSize); 682868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ( 683868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kFinalReadSize, 684868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ReadData(entry, i, kReadBufferSize, buffer2.get(), kReadBufferSize)); 685868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(0, 686868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) memcmp(reference_buffers[i]->data() + kReadBufferSize, 687868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer2->data(), 688868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kFinalReadSize)); 689c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) } 690c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 691c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) entry->Close(); 6925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 6935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 6945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, StreamAccess) { 6955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 6965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) StreamAccess(); 6975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 6985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 6995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlyStreamAccess) { 7005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 7015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 7025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) StreamAccess(); 7035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 7045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::GetKey() { 7065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key("the first key"); 7075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 7085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 7095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(key, entry->GetKey()) << "short key"; 7105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 7115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int seed = static_cast<int>(Time::Now().ToInternalValue()); 7135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) srand(seed); 7145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) char key_buffer[20000]; 7155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(key_buffer, 3000, true); 7175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) key_buffer[1000] = '\0'; 7185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) key = key_buffer; 7205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 7215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(key == entry->GetKey()) << "1000 bytes key"; 7225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 7235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) key_buffer[1000] = 'p'; 7255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) key_buffer[3000] = '\0'; 7265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) key = key_buffer; 7275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 7285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(key == entry->GetKey()) << "medium size key"; 7295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 7305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(key_buffer, sizeof(key_buffer), true); 7325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) key_buffer[19999] = '\0'; 7335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) key = key_buffer; 7355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 7365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(key == entry->GetKey()) << "long key"; 7375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 7385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(key_buffer, 0x4000, true); 7405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) key_buffer[0x4000] = '\0'; 7415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) key = key_buffer; 7435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 7445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(key == entry->GetKey()) << "16KB key"; 7455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 7465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 7475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, GetKey) { 7495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 7505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) GetKey(); 7515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 7525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlyGetKey) { 7545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 7555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 7565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) GetKey(); 7575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 7585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::GetTimes() { 7605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key("the first key"); 7615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 7625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Time t1 = Time::Now(); 7645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 7655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(entry->GetLastModified() >= t1); 7665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(entry->GetLastModified() == entry->GetLastUsed()); 7675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) AddDelay(); 7695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Time t2 = Time::Now(); 7705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(t2 > t1); 7715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, WriteData(entry, 0, 200, NULL, 0, false)); 7725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (type_ == net::APP_CACHE) { 7735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(entry->GetLastModified() < t2); 7745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } else { 7755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(entry->GetLastModified() >= t2); 7765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 7775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(entry->GetLastModified() == entry->GetLastUsed()); 7785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) AddDelay(); 7805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Time t3 = Time::Now(); 7815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(t3 > t2); 7825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize = 200; 7835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize)); 784868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer.get(), kSize)); 7855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (type_ == net::APP_CACHE) { 7865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(entry->GetLastUsed() < t2); 7875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(entry->GetLastModified() < t2); 7882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } else if (type_ == net::SHADER_CACHE) { 7892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) EXPECT_TRUE(entry->GetLastUsed() < t3); 7902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) EXPECT_TRUE(entry->GetLastModified() < t3); 7915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } else { 7925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(entry->GetLastUsed() >= t3); 7935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(entry->GetLastModified() < t3); 7945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 7955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 7965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 7975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, GetTimes) { 7995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 8005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) GetTimes(); 8015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 8025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlyGetTimes) { 8045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 8055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 8065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) GetTimes(); 8075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 8085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, AppCacheGetTimes) { 8105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetCacheType(net::APP_CACHE); 8115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 8125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) GetTimes(); 8135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 8145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)TEST_F(DiskCacheEntryTest, ShaderCacheGetTimes) { 8162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) SetCacheType(net::SHADER_CACHE); 8172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) InitCache(); 8182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) GetTimes(); 8192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 8202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::GrowData() { 8225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key1("the first key"); 8235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 8245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key1, &entry)); 8255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize = 20000; 8275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize)); 8285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize)); 8295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer1->data(), kSize, false); 8305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) memset(buffer2->data(), 0, kSize); 8315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::strlcpy(buffer1->data(), "the data", kSize); 833868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(10, WriteData(entry, 0, 0, buffer1.get(), 10, false)); 834868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(10, ReadData(entry, 0, 0, buffer2.get(), 10)); 8355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_STREQ("the data", buffer2->data()); 8365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(10, entry->GetDataSize(0)); 8375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 838868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(2000, WriteData(entry, 0, 0, buffer1.get(), 2000, false)); 8395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(2000, entry->GetDataSize(0)); 840868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(2000, ReadData(entry, 0, 0, buffer2.get(), 2000)); 8415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 2000)); 8425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 843868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1.get(), kSize, false)); 8445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(20000, entry->GetDataSize(0)); 845868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(20000, ReadData(entry, 0, 0, buffer2.get(), kSize)); 8465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), kSize)); 8475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 8485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) memset(buffer2->data(), 0, kSize); 8505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key2("Second key"); 8515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key2, &entry)); 852868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(10, WriteData(entry, 0, 0, buffer1.get(), 10, false)); 8535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(10, entry->GetDataSize(0)); 8545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 8555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Go from an internal address to a bigger block size. 8575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key2, &entry)); 858868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(2000, WriteData(entry, 0, 0, buffer1.get(), 2000, false)); 8595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(2000, entry->GetDataSize(0)); 860868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(2000, ReadData(entry, 0, 0, buffer2.get(), 2000)); 8615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 2000)); 8625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 8635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) memset(buffer2->data(), 0, kSize); 8645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Go from an internal address to an external one. 8665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key2, &entry)); 867868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1.get(), kSize, false)); 8685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(20000, entry->GetDataSize(0)); 869868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(20000, ReadData(entry, 0, 0, buffer2.get(), kSize)); 8705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), kSize)); 8715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 8725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Double check the size from disk. 8745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key2, &entry)); 8755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(20000, entry->GetDataSize(0)); 8765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Now extend the entry without actual data. 878868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(0, WriteData(entry, 0, 45500, buffer1.get(), 0, false)); 8795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 8805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // And check again from disk. 8825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key2, &entry)); 8835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(45500, entry->GetDataSize(0)); 8845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 8855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 8865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, GrowData) { 8885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 8895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) GrowData(); 8905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 8915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, GrowDataNoBuffer) { 8935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 8945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) cache_impl_->SetFlags(disk_cache::kNoBuffering); 8955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) GrowData(); 8965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 8975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlyGrowData) { 8995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 9005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 9015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) GrowData(); 9025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 9035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::TruncateData() { 9055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key("the first key"); 9065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 9075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 9085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize1 = 20000; 9105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize2 = 20000; 9115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1)); 9125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2)); 9135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer1->data(), kSize1, false); 9155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) memset(buffer2->data(), 0, kSize2); 9165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Simple truncation: 918868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(200, WriteData(entry, 0, 0, buffer1.get(), 200, false)); 9195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(200, entry->GetDataSize(0)); 920868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(100, WriteData(entry, 0, 0, buffer1.get(), 100, false)); 9215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(200, entry->GetDataSize(0)); 922868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(100, WriteData(entry, 0, 0, buffer1.get(), 100, true)); 9235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(100, entry->GetDataSize(0)); 924868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(0, WriteData(entry, 0, 50, buffer1.get(), 0, true)); 9255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(50, entry->GetDataSize(0)); 926868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(0, WriteData(entry, 0, 0, buffer1.get(), 0, true)); 9275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, entry->GetDataSize(0)); 9285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 9295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key, &entry)); 9305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Go to an external file. 932868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1.get(), 20000, true)); 9335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(20000, entry->GetDataSize(0)); 934868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(20000, ReadData(entry, 0, 0, buffer2.get(), 20000)); 9355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 20000)); 9365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) memset(buffer2->data(), 0, kSize2); 9375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // External file truncation 939868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(18000, WriteData(entry, 0, 0, buffer1.get(), 18000, false)); 9405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(20000, entry->GetDataSize(0)); 941868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(18000, WriteData(entry, 0, 0, buffer1.get(), 18000, true)); 9425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(18000, entry->GetDataSize(0)); 943868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(0, WriteData(entry, 0, 17500, buffer1.get(), 0, true)); 9445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(17500, entry->GetDataSize(0)); 9455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // And back to an internal block. 947868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(600, WriteData(entry, 0, 1000, buffer1.get(), 600, true)); 9485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(1600, entry->GetDataSize(0)); 949868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(600, ReadData(entry, 0, 1000, buffer2.get(), 600)); 9505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 600)); 951868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(1000, ReadData(entry, 0, 0, buffer2.get(), 1000)); 952868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer1->data(), buffer2->data(), 1000)) 953868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) << "Preserves previous data"; 9545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Go from external file to zero length. 956868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer1.get(), 20000, true)); 9575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(20000, entry->GetDataSize(0)); 958868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(0, WriteData(entry, 0, 0, buffer1.get(), 0, true)); 9595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, entry->GetDataSize(0)); 9605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 9625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 9635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, TruncateData) { 9655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 9665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) TruncateData(); 9675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 9685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, TruncateDataNoBuffer) { 9705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 9715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) cache_impl_->SetFlags(disk_cache::kNoBuffering); 9725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) TruncateData(); 9735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 9745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlyTruncateData) { 9765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 9775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 9785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) TruncateData(); 9795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 9805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::ZeroLengthIO() { 9825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key("the first key"); 9835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 9845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 9855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, ReadData(entry, 0, 0, NULL, 0)); 9875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, WriteData(entry, 0, 0, NULL, 0, false)); 9885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // This write should extend the entry. 9905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, WriteData(entry, 0, 1000, NULL, 0, false)); 9915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, ReadData(entry, 0, 500, NULL, 0)); 9925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, ReadData(entry, 0, 2000, NULL, 0)); 9935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(1000, entry->GetDataSize(0)); 9945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, WriteData(entry, 0, 100000, NULL, 0, true)); 9965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, ReadData(entry, 0, 50000, NULL, 0)); 9975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(100000, entry->GetDataSize(0)); 9985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Let's verify the actual content. 10005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize = 20; 10015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const char zeros[kSize] = {}; 10025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize)); 10035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer->data(), kSize, false); 1005868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, ReadData(entry, 0, 500, buffer.get(), kSize)); 10065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer->data(), zeros, kSize)); 10075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer->data(), kSize, false); 1009868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, ReadData(entry, 0, 5000, buffer.get(), kSize)); 10105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer->data(), zeros, kSize)); 10115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer->data(), kSize, false); 1013868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, ReadData(entry, 0, 50000, buffer.get(), kSize)); 10145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer->data(), zeros, kSize)); 10155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 10175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 10185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, ZeroLengthIO) { 10205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 10215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ZeroLengthIO(); 10225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 10235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, ZeroLengthIONoBuffer) { 10255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 10265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) cache_impl_->SetFlags(disk_cache::kNoBuffering); 10275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ZeroLengthIO(); 10285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 10295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlyZeroLengthIO) { 10315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 10325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 10335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ZeroLengthIO(); 10345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 10355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1036b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles)// Tests that we handle the content correctly when buffering, a feature of the 1037b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles)// standard cache that permits fast responses to certain reads. 10385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::Buffering() { 10395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key("the first key"); 10405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 10415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 10425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize = 200; 10445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize)); 10455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize)); 10465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer1->data(), kSize, true); 10475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer2->data(), kSize, true); 10485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1049868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer1.get(), kSize, false)); 10505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 10515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Write a little more and read what we wrote before. 10535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key, &entry)); 1054868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteData(entry, 1, 5000, buffer1.get(), kSize, false)); 1055868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, ReadData(entry, 1, 0, buffer2.get(), kSize)); 10565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize)); 10575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Now go to an external file. 1059868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteData(entry, 1, 18000, buffer1.get(), kSize, false)); 10605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 10615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Write something else and verify old data. 10635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key, &entry)); 1064868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteData(entry, 1, 10000, buffer1.get(), kSize, false)); 10655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer2->data(), kSize, true); 1066868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, ReadData(entry, 1, 5000, buffer2.get(), kSize)); 10675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize)); 10685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer2->data(), kSize, true); 1069868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, ReadData(entry, 1, 0, buffer2.get(), kSize)); 10705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize)); 10715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer2->data(), kSize, true); 1072868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, ReadData(entry, 1, 18000, buffer2.get(), kSize)); 10735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize)); 10745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Extend the file some more. 1076868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteData(entry, 1, 23000, buffer1.get(), kSize, false)); 10775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 10785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // And now make sure that we can deal with data in both places (ram/disk). 10805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key, &entry)); 1081868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteData(entry, 1, 17000, buffer1.get(), kSize, false)); 10825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // We should not overwrite the data at 18000 with this. 1084868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteData(entry, 1, 19000, buffer1.get(), kSize, false)); 10855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer2->data(), kSize, true); 1086868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, ReadData(entry, 1, 18000, buffer2.get(), kSize)); 10875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize)); 10885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer2->data(), kSize, true); 1089868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, ReadData(entry, 1, 17000, buffer2.get(), kSize)); 10905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize)); 10915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1092868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteData(entry, 1, 22900, buffer1.get(), kSize, false)); 10935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer2->data(), kSize, true); 1094868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(100, ReadData(entry, 1, 23000, buffer2.get(), kSize)); 10955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + 100, 100)); 10965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer2->data(), kSize, true); 1098868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(100, ReadData(entry, 1, 23100, buffer2.get(), kSize)); 10995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + 100, 100)); 11005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 11015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Extend the file again and read before without closing the entry. 1102868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteData(entry, 1, 25000, buffer1.get(), kSize, false)); 1103868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteData(entry, 1, 45000, buffer1.get(), kSize, false)); 11045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer2->data(), kSize, true); 1105868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, ReadData(entry, 1, 25000, buffer2.get(), kSize)); 11065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize)); 11075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer2->data(), kSize, true); 1108868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, ReadData(entry, 1, 45000, buffer2.get(), kSize)); 11095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data(), kSize)); 11105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 11115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 11125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 11135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 11145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, Buffering) { 11155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 11165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Buffering(); 11175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 11185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 11195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, BufferingNoBuffer) { 11205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 11215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) cache_impl_->SetFlags(disk_cache::kNoBuffering); 11225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Buffering(); 11235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 11245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1125c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// Checks that entries are zero length when created. 1126c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)void DiskCacheEntryTest::SizeAtCreate() { 1127c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const char key[] = "the first key"; 1128c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* entry; 1129c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 1130c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 1131c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const int kNumStreams = 3; 1132c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) for (int i = 0; i < kNumStreams; ++i) 1133c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_EQ(0, entry->GetDataSize(i)); 1134c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) entry->Close(); 1135c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 1136c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 1137c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SizeAtCreate) { 1138c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 1139c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SizeAtCreate(); 1140c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 1141c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 1142c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlySizeAtCreate) { 1143c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetMemoryOnlyMode(); 1144c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 1145c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SizeAtCreate(); 1146c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 1147c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 11485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Some extra tests to make sure that buffering works properly when changing 11495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// the entry size. 11505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::SizeChanges() { 11515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key("the first key"); 11525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 11535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 11545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 11555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize = 200; 11565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const char zeros[kSize] = {}; 11575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize)); 11585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize)); 11595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer1->data(), kSize, true); 11605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer2->data(), kSize, true); 11615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1162868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer1.get(), kSize, true)); 1163868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteData(entry, 1, 17000, buffer1.get(), kSize, true)); 1164868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteData(entry, 1, 23000, buffer1.get(), kSize, true)); 11655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 11665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 11675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Extend the file and read between the old size and the new write. 11685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key, &entry)); 11695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(23000 + kSize, entry->GetDataSize(1)); 1170868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteData(entry, 1, 25000, buffer1.get(), kSize, true)); 11715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(25000 + kSize, entry->GetDataSize(1)); 1172868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, ReadData(entry, 1, 24000, buffer2.get(), kSize)); 11735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer2->data(), zeros, kSize)); 11745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 11755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Read at the end of the old file size. 1176868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, 1177868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ReadData(entry, 1, 23000 + kSize - 35, buffer2.get(), kSize)); 11785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + kSize - 35, 35)); 11795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 11805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Read slightly before the last write. 11815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer2->data(), kSize, true); 1182868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, ReadData(entry, 1, 24900, buffer2.get(), kSize)); 11835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100)); 11845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100)); 11855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 11865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Extend the entry a little more. 1187868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteData(entry, 1, 26000, buffer1.get(), kSize, true)); 11885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(26000 + kSize, entry->GetDataSize(1)); 11895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer2->data(), kSize, true); 1190868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, ReadData(entry, 1, 25900, buffer2.get(), kSize)); 11915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100)); 11925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100)); 11935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 11945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // And now reduce the size. 1195868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteData(entry, 1, 25000, buffer1.get(), kSize, true)); 11965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(25000 + kSize, entry->GetDataSize(1)); 1197868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(28, ReadData(entry, 1, 25000 + kSize - 28, buffer2.get(), kSize)); 11985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer2->data(), buffer1->data() + kSize - 28, 28)); 11995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 12005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Reduce the size with a buffer that is not extending the size. 1201868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteData(entry, 1, 24000, buffer1.get(), kSize, false)); 12025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(25000 + kSize, entry->GetDataSize(1)); 1203868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteData(entry, 1, 24500, buffer1.get(), kSize, true)); 12045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(24500 + kSize, entry->GetDataSize(1)); 1205868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, ReadData(entry, 1, 23900, buffer2.get(), kSize)); 12065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100)); 12075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100)); 12085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 12095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // And now reduce the size below the old size. 1210868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteData(entry, 1, 19000, buffer1.get(), kSize, true)); 12115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(19000 + kSize, entry->GetDataSize(1)); 1212868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, ReadData(entry, 1, 18900, buffer2.get(), kSize)); 12135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer2->data(), zeros, 100)); 12145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer2->data() + 100, buffer1->data(), kSize - 100)); 12155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 12165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Verify that the actual file is truncated. 12175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 12185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key, &entry)); 12195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(19000 + kSize, entry->GetDataSize(1)); 12205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1221c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Extend the newly opened file with a zero length write, expect zero fill. 1222868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(0, WriteData(entry, 1, 20000 + kSize, buffer1.get(), 0, false)); 1223868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, ReadData(entry, 1, 19000 + kSize, buffer1.get(), kSize)); 1224c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_EQ(0, memcmp(buffer1->data(), zeros, kSize)); 1225c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 12265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 12275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 12285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 12295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, SizeChanges) { 12305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 12315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SizeChanges(); 12325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 12335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 12345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, SizeChangesNoBuffer) { 12355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 12365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) cache_impl_->SetFlags(disk_cache::kNoBuffering); 12375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SizeChanges(); 12385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 12395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 12405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Write more than the total cache capacity but to a single entry. |size| is the 12415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// amount of bytes to write each time. 12425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::ReuseEntry(int size) { 12435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key1("the first key"); 12445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 12455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key1, &entry)); 12465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 12475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 12485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key2("the second key"); 12495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key2, &entry)); 12505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 12515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(size)); 12525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer->data(), size, false); 12535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 12545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) for (int i = 0; i < 15; i++) { 1255868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(0, WriteData(entry, 0, 0, buffer.get(), 0, true)); 1256868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(size, WriteData(entry, 0, 0, buffer.get(), size, false)); 12575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 12585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key2, &entry)); 12595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 12605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 12615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 12625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key1, &entry)) << "have not evicted this entry"; 12635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 12645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 12655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 12665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, ReuseExternalEntry) { 12675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMaxSize(200 * 1024); 12685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 12695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ReuseEntry(20 * 1024); 12705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 12715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 12725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlyReuseExternalEntry) { 12735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 12745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMaxSize(200 * 1024); 12755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 12765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ReuseEntry(20 * 1024); 12775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 12785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 12795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, ReuseInternalEntry) { 12805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMaxSize(100 * 1024); 12815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 12825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ReuseEntry(10 * 1024); 12835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 12845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 12855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlyReuseInternalEntry) { 12865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 12875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMaxSize(100 * 1024); 12885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 12895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ReuseEntry(10 * 1024); 12905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 12915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 12925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Reading somewhere that was not written should return zeros. 12935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::InvalidData() { 12945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key("the first key"); 12955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 12965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 12975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 12985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize1 = 20000; 12995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize2 = 20000; 13005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize3 = 20000; 13015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1)); 13025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2)); 13035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer3(new net::IOBuffer(kSize3)); 13045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 13055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer1->data(), kSize1, false); 13065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) memset(buffer2->data(), 0, kSize2); 13075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 13085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Simple data grow: 1309868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(200, WriteData(entry, 0, 400, buffer1.get(), 200, false)); 13105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(600, entry->GetDataSize(0)); 1311868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(100, ReadData(entry, 0, 300, buffer3.get(), 100)); 13125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100)); 13135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 13145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key, &entry)); 13155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 13165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // The entry is now on disk. Load it and extend it. 1317868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(200, WriteData(entry, 0, 800, buffer1.get(), 200, false)); 13185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(1000, entry->GetDataSize(0)); 1319868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(100, ReadData(entry, 0, 700, buffer3.get(), 100)); 13205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100)); 13215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 13225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key, &entry)); 13235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 13245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // This time using truncate. 1325868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(200, WriteData(entry, 0, 1800, buffer1.get(), 200, true)); 13265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(2000, entry->GetDataSize(0)); 1327868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(100, ReadData(entry, 0, 1500, buffer3.get(), 100)); 13285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 100)); 13295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 13305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Go to an external file. 1331868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(200, WriteData(entry, 0, 19800, buffer1.get(), 200, false)); 13325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(20000, entry->GetDataSize(0)); 1333868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(4000, ReadData(entry, 0, 14000, buffer3.get(), 4000)); 13345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 4000)); 13355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 13365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // And back to an internal block. 1337868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(600, WriteData(entry, 0, 1000, buffer1.get(), 600, true)); 13385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(1600, entry->GetDataSize(0)); 1339868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(600, ReadData(entry, 0, 1000, buffer3.get(), 600)); 13405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer3->data(), buffer1->data(), 600)); 13415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 13425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Extend it again. 1343868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(600, WriteData(entry, 0, 2000, buffer1.get(), 600, false)); 13445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(2600, entry->GetDataSize(0)); 1345868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(200, ReadData(entry, 0, 1800, buffer3.get(), 200)); 13465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 200)); 13475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 13485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // And again (with truncation flag). 1349868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(600, WriteData(entry, 0, 3000, buffer1.get(), 600, true)); 13505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(3600, entry->GetDataSize(0)); 1351868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(200, ReadData(entry, 0, 2800, buffer3.get(), 200)); 13525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(!memcmp(buffer3->data(), buffer2->data(), 200)); 13535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 13545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 13555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 13565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 13575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, InvalidData) { 13585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 13595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InvalidData(); 13605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 13615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 13625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, InvalidDataNoBuffer) { 13635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 13645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) cache_impl_->SetFlags(disk_cache::kNoBuffering); 13655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InvalidData(); 13665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 13675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 13685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlyInvalidData) { 13695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 13705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 13715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InvalidData(); 13725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 13735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 13745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Tests that the cache preserves the buffer of an IO operation. 1375c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)void DiskCacheEntryTest::ReadWriteDestroyBuffer() { 13765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key("the first key"); 13775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 13785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 13795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 13805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize = 200; 13815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize)); 13825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer->data(), kSize, false); 13835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 13845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) net::TestCompletionCallback cb; 13855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(net::ERR_IO_PENDING, 1386868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->WriteData(0, 0, buffer.get(), kSize, cb.callback(), false)); 13875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 13885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Release our reference to the buffer. 13895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) buffer = NULL; 13905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(kSize, cb.WaitForResult()); 13915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 13925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // And now test with a Read(). 13935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) buffer = new net::IOBuffer(kSize); 13945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer->data(), kSize, false); 13955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 13965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(net::ERR_IO_PENDING, 1397868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->ReadData(0, 0, buffer.get(), kSize, cb.callback())); 13985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) buffer = NULL; 13995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(kSize, cb.WaitForResult()); 14005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 14015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 14025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 14035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1404c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, ReadWriteDestroyBuffer) { 1405c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 1406c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ReadWriteDestroyBuffer(); 1407c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 1408c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 14095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::DoomNormalEntry() { 14105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key("the first key"); 14115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 14125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 14135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Doom(); 14145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 14155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 14165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize = 20000; 14175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize)); 14185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer->data(), kSize, true); 14195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) buffer->data()[19999] = '\0'; 14205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 14215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) key = buffer->data(); 14225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 1423868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(20000, WriteData(entry, 0, 0, buffer.get(), kSize, false)); 1424868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(20000, WriteData(entry, 1, 0, buffer.get(), kSize, false)); 14255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Doom(); 14265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 14275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 14285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) FlushQueueForTest(); 14295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, cache_->GetEntryCount()); 14305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 14315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 14325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, DoomEntry) { 14335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 14345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DoomNormalEntry(); 14355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 14365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 14375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlyDoomEntry) { 14385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 14395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 14405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DoomNormalEntry(); 14415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 14425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 14435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Tests dooming an entry that's linked to an open entry. 14445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::DoomEntryNextToOpenEntry() { 14455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry1; 14465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry2; 14475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry("fixed", &entry1)); 14485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry1->Close(); 14495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry("foo", &entry1)); 14505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry1->Close(); 14515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry("bar", &entry1)); 14525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry1->Close(); 14535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 14545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry("foo", &entry1)); 14555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry("bar", &entry2)); 14565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry2->Doom(); 14575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry2->Close(); 14585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 14595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry("foo", &entry2)); 14605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry2->Doom(); 14615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry2->Close(); 14625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry1->Close(); 14635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 14645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry("fixed", &entry1)); 14655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry1->Close(); 14665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 14675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 14685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, DoomEntryNextToOpenEntry) { 1469c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 14705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DoomEntryNextToOpenEntry(); 14715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 14725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 14735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, NewEvictionDoomEntryNextToOpenEntry) { 14745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetNewEviction(); 1475c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 14765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DoomEntryNextToOpenEntry(); 14775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 14785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 14795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, AppCacheDoomEntryNextToOpenEntry) { 14805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetCacheType(net::APP_CACHE); 1481c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 14825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DoomEntryNextToOpenEntry(); 14835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 14845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 14855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Verify that basic operations work as expected with doomed entries. 14865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::DoomedEntry() { 14875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key("the first key"); 14885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 14895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 14905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Doom(); 14915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 14925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) FlushQueueForTest(); 14935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, cache_->GetEntryCount()); 14945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Time initial = Time::Now(); 14955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) AddDelay(); 14965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 14975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize1 = 2000; 14985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize2 = 2000; 14995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1)); 15005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2)); 15015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer1->data(), kSize1, false); 15025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) memset(buffer2->data(), 0, kSize2); 15035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1504868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(2000, WriteData(entry, 0, 0, buffer1.get(), 2000, false)); 1505868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(2000, ReadData(entry, 0, 0, buffer2.get(), 2000)); 15065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, memcmp(buffer1->data(), buffer2->data(), kSize1)); 15075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(key, entry->GetKey()); 15085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(initial < entry->GetLastModified()); 15095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(initial < entry->GetLastUsed()); 15105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 15115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 15125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 15135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 15145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, DoomedEntry) { 15155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 15165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DoomedEntry(); 15175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 15185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 15195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlyDoomedEntry) { 15205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 15215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 15225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DoomedEntry(); 15235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 15245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 15255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Tests that we discard entries if the data is missing. 15265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MissingData) { 15275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 15285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 15295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key("the first key"); 15305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 15315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 15325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 15335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Write to an external file. 15345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize = 20000; 15355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize)); 15365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buffer->data(), kSize, false); 1537868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false)); 15385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 15395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) FlushQueueForTest(); 15405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 15415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Addr address(0x80000001); 15422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) base::FilePath name = cache_impl_->GetFileName(address); 15437dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch EXPECT_TRUE(base::DeleteFile(name, false)); 15445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 15455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Attempt to read the data. 15465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key, &entry)); 1547868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(net::ERR_FILE_NOT_FOUND, 1548868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ReadData(entry, 0, 0, buffer.get(), kSize)); 15495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 15505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 15515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // The entry should be gone. 15525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_NE(net::OK, OpenEntry(key, &entry)); 15535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 15545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 15555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Test that child entries in a memory cache backend are not visible from 15565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// enumerations. 15575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlyEnumerationWithSparseEntries) { 15585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 15595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 15605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 15615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize = 4096; 15625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize)); 15635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buf->data(), kSize, false); 15645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 15655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key("the first key"); 15665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* parent_entry; 15675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &parent_entry)); 15685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 15695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Writes to the parent entry. 1570868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, 1571868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) parent_entry->WriteSparseData( 1572868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, buf.get(), kSize, net::CompletionCallback())); 15735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 15745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // This write creates a child entry and writes to it. 1575868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, 1576868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) parent_entry->WriteSparseData( 1577868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 8192, buf.get(), kSize, net::CompletionCallback())); 15785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 15795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) parent_entry->Close(); 15805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 15815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Perform the enumerations. 15825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void* iter = NULL; 15835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry = NULL; 15845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int count = 0; 15855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) while (OpenNextEntry(&iter, &entry) == net::OK) { 15865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_TRUE(entry != NULL); 15875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ++count; 15885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::MemEntryImpl* mem_entry = 15895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) reinterpret_cast<disk_cache::MemEntryImpl*>(entry); 15905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(disk_cache::MemEntryImpl::kParentEntry, mem_entry->type()); 15915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) mem_entry->Close(); 15925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 15935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(1, count); 15945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 15955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 15965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Writes |buf_1| to offset and reads it back as |buf_2|. 15975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void VerifySparseIO(disk_cache::Entry* entry, int64 offset, 15985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) net::IOBuffer* buf_1, int size, net::IOBuffer* buf_2) { 15995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) net::TestCompletionCallback cb; 16005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 16015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) memset(buf_2->data(), 0, size); 16025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int ret = entry->ReadSparseData(offset, buf_2, size, cb.callback()); 16035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, cb.GetResult(ret)); 16045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 16055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ret = entry->WriteSparseData(offset, buf_1, size, cb.callback()); 16065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(size, cb.GetResult(ret)); 16075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 16085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ret = entry->ReadSparseData(offset, buf_2, size, cb.callback()); 16095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(size, cb.GetResult(ret)); 16105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 16115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, memcmp(buf_1->data(), buf_2->data(), size)); 16125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 16135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 16145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Reads |size| bytes from |entry| at |offset| and verifies that they are the 16155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// same as the content of the provided |buffer|. 16165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void VerifyContentSparseIO(disk_cache::Entry* entry, int64 offset, char* buffer, 16175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int size) { 16185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) net::TestCompletionCallback cb; 16195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 16205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(size)); 16215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) memset(buf_1->data(), 0, size); 1622868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) int ret = entry->ReadSparseData(offset, buf_1.get(), size, cb.callback()); 16235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(size, cb.GetResult(ret)); 16245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, memcmp(buf_1->data(), buffer, size)); 16255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 16265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 16275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::BasicSparseIO() { 16285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key("the first key"); 16295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 16305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 16315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 16325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize = 2048; 16335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize)); 16345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize)); 16355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buf_1->data(), kSize, false); 16365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 16375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Write at offset 0. 1638868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) VerifySparseIO(entry, 0, buf_1.get(), kSize, buf_2.get()); 16395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 16405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Write at offset 0x400000 (4 MB). 1641868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) VerifySparseIO(entry, 0x400000, buf_1.get(), kSize, buf_2.get()); 16425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 16435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Write at offset 0x800000000 (32 GB). 1644868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) VerifySparseIO(entry, 0x800000000LL, buf_1.get(), kSize, buf_2.get()); 16455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 16465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 16475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 16485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Check everything again. 16495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key, &entry)); 16505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) VerifyContentSparseIO(entry, 0, buf_1->data(), kSize); 16515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) VerifyContentSparseIO(entry, 0x400000, buf_1->data(), kSize); 16525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) VerifyContentSparseIO(entry, 0x800000000LL, buf_1->data(), kSize); 16535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 16545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 16555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 16565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, BasicSparseIO) { 16575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 16585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) BasicSparseIO(); 16595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 16605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 16615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlyBasicSparseIO) { 16625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 16635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 16645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) BasicSparseIO(); 16655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 16665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 16675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::HugeSparseIO() { 16685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key("the first key"); 16695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 16705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 16715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 16725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Write 1.2 MB so that we cover multiple entries. 16735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize = 1200 * 1024; 16745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize)); 16755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize)); 16765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buf_1->data(), kSize, false); 16775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 16785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Write at offset 0x20F0000 (33 MB - 64 KB). 1679868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) VerifySparseIO(entry, 0x20F0000, buf_1.get(), kSize, buf_2.get()); 16805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 16815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 16825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Check it again. 16835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key, &entry)); 16845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) VerifyContentSparseIO(entry, 0x20F0000, buf_1->data(), kSize); 16855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 16865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 16875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 16885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, HugeSparseIO) { 16895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 16905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) HugeSparseIO(); 16915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 16925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 16935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlyHugeSparseIO) { 16945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 16955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 16965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) HugeSparseIO(); 16975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 16985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 16995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::GetAvailableRange() { 17005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key("the first key"); 17015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 17025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 17035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 17045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize = 16 * 1024; 17055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize)); 17065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buf->data(), kSize, false); 17075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 17085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Write at offset 0x20F0000 (33 MB - 64 KB), and 0x20F4400 (33 MB - 47 KB). 1709868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F0000, buf.get(), kSize)); 1710868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F4400, buf.get(), kSize)); 17115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 17125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // We stop at the first empty block. 17135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int64 start; 17145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) net::TestCompletionCallback cb; 17155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int rv = entry->GetAvailableRange( 17165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 0x20F0000, kSize * 2, &start, cb.callback()); 17175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(kSize, cb.GetResult(rv)); 17185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0x20F0000, start); 17195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 17205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) start = 0; 17215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) rv = entry->GetAvailableRange(0, kSize, &start, cb.callback()); 17225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, cb.GetResult(rv)); 17235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) rv = entry->GetAvailableRange( 17245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 0x20F0000 - kSize, kSize, &start, cb.callback()); 17255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, cb.GetResult(rv)); 17265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) rv = entry->GetAvailableRange(0, 0x2100000, &start, cb.callback()); 17275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(kSize, cb.GetResult(rv)); 17285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0x20F0000, start); 17295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 17305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // We should be able to Read based on the results of GetAvailableRange. 17315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) start = -1; 17325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) rv = entry->GetAvailableRange(0x2100000, kSize, &start, cb.callback()); 17335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, cb.GetResult(rv)); 1734868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) rv = entry->ReadSparseData(start, buf.get(), kSize, cb.callback()); 17355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, cb.GetResult(rv)); 17365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 17375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) start = 0; 17385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) rv = entry->GetAvailableRange(0x20F2000, kSize, &start, cb.callback()); 17395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0x2000, cb.GetResult(rv)); 17405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0x20F2000, start); 1741868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(0x2000, ReadSparseData(entry, start, buf.get(), kSize)); 17425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 17435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Make sure that we respect the |len| argument. 17445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) start = 0; 17455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) rv = entry->GetAvailableRange( 17465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 0x20F0001 - kSize, kSize, &start, cb.callback()); 17475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(1, cb.GetResult(rv)); 17485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0x20F0000, start); 17495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 17505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 17515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 17525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 17535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, GetAvailableRange) { 17545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 17555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) GetAvailableRange(); 17565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 17575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 17585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlyGetAvailableRange) { 17595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 17605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 17615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) GetAvailableRange(); 17625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 17635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 17645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::CouldBeSparse() { 17655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key("the first key"); 17665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 17675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 17685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 17695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize = 16 * 1024; 17705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize)); 17715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buf->data(), kSize, false); 17725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 17735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Write at offset 0x20F0000 (33 MB - 64 KB). 1774868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteSparseData(entry, 0x20F0000, buf.get(), kSize)); 17755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 17765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(entry->CouldBeSparse()); 17775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 17785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 17795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key, &entry)); 17805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(entry->CouldBeSparse()); 17815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 17825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 17835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Now verify a regular entry. 17845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) key.assign("another key"); 17855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 17865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_FALSE(entry->CouldBeSparse()); 17875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1788868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteData(entry, 0, 0, buf.get(), kSize, false)); 1789868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteData(entry, 1, 0, buf.get(), kSize, false)); 1790868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteData(entry, 2, 0, buf.get(), kSize, false)); 17915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 17925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_FALSE(entry->CouldBeSparse()); 17935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 17945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 17955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key, &entry)); 17965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_FALSE(entry->CouldBeSparse()); 17975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 17985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 17995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 18005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, CouldBeSparse) { 18015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 18025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CouldBeSparse(); 18035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 18045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 18055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryCouldBeSparse) { 18065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 18075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 18085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CouldBeSparse(); 18095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 18105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 18115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedSparseIO) { 18125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 18135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 18145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 18155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize = 8192; 18165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize)); 18175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize)); 18185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buf_1->data(), kSize, false); 18195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 18205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key("the first key"); 18215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 18225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 18235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 18245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // This loop writes back to back starting from offset 0 and 9000. 18255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) for (int i = 0; i < kSize; i += 1024) { 18265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::WrappedIOBuffer> buf_3( 18275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) new net::WrappedIOBuffer(buf_1->data() + i)); 1828868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) VerifySparseIO(entry, i, buf_3.get(), 1024, buf_2.get()); 1829868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) VerifySparseIO(entry, 9000 + i, buf_3.get(), 1024, buf_2.get()); 18305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 18315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 18325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Make sure we have data written. 18335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) VerifyContentSparseIO(entry, 0, buf_1->data(), kSize); 18345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) VerifyContentSparseIO(entry, 9000, buf_1->data(), kSize); 18355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 18365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // This tests a large write that spans 3 entries from a misaligned offset. 1837868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) VerifySparseIO(entry, 20481, buf_1.get(), 8192, buf_2.get()); 18385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 18395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 18405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 18415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 18425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlyMisalignedGetAvailableRange) { 18435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 18445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 18455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 18465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize = 8192; 18475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize)); 18485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buf->data(), kSize, false); 18495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 18505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 18515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key("the first key"); 18525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 18535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 18545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Writes in the middle of an entry. 1855868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ( 1856868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1024, 1857868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->WriteSparseData(0, buf.get(), 1024, net::CompletionCallback())); 1858868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ( 1859868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1024, 1860868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->WriteSparseData(5120, buf.get(), 1024, net::CompletionCallback())); 1861868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(1024, 1862868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->WriteSparseData( 1863868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 10000, buf.get(), 1024, net::CompletionCallback())); 18645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 18655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Writes in the middle of an entry and spans 2 child entries. 1866868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(8192, 1867868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->WriteSparseData( 1868868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 50000, buf.get(), 8192, net::CompletionCallback())); 18695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 18705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int64 start; 18715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) net::TestCompletionCallback cb; 18725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Test that we stop at a discontinuous child at the second block. 18735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int rv = entry->GetAvailableRange(0, 10000, &start, cb.callback()); 18745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(1024, cb.GetResult(rv)); 18755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, start); 18765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 18775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Test that number of bytes is reported correctly when we start from the 18785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // middle of a filled region. 18795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) rv = entry->GetAvailableRange(512, 10000, &start, cb.callback()); 18805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(512, cb.GetResult(rv)); 18815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(512, start); 18825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 18835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Test that we found bytes in the child of next block. 18845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) rv = entry->GetAvailableRange(1024, 10000, &start, cb.callback()); 18855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(1024, cb.GetResult(rv)); 18865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(5120, start); 18875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 18885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Test that the desired length is respected. It starts within a filled 18895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // region. 18905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) rv = entry->GetAvailableRange(5500, 512, &start, cb.callback()); 18915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(512, cb.GetResult(rv)); 18925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(5500, start); 18935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 18945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Test that the desired length is respected. It starts before a filled 18955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // region. 18965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) rv = entry->GetAvailableRange(5000, 620, &start, cb.callback()); 18975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(500, cb.GetResult(rv)); 18985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(5120, start); 18995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 19005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Test that multiple blocks are scanned. 19015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) rv = entry->GetAvailableRange(40000, 20000, &start, cb.callback()); 19025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(8192, cb.GetResult(rv)); 19035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(50000, start); 19045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 19055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 19065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 19075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 19085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::UpdateSparseEntry() { 19095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key("the first key"); 19105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry1; 19115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry1)); 19125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 19135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize = 2048; 19145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buf_1(new net::IOBuffer(kSize)); 19155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buf_2(new net::IOBuffer(kSize)); 19165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buf_1->data(), kSize, false); 19175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 19185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Write at offset 0. 1919868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) VerifySparseIO(entry1, 0, buf_1.get(), kSize, buf_2.get()); 19205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry1->Close(); 19215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 19225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Write at offset 2048. 19235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key, &entry1)); 1924868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) VerifySparseIO(entry1, 2048, buf_1.get(), kSize, buf_2.get()); 19255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 19265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry2; 19275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry("the second key", &entry2)); 19285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 19295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry1->Close(); 19305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry2->Close(); 19315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) FlushQueueForTest(); 19325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (memory_only_) 19335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(2, cache_->GetEntryCount()); 19345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) else 19355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(3, cache_->GetEntryCount()); 19365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 19375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 19385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, UpdateSparseEntry) { 19395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetCacheType(net::MEDIA_CACHE); 19405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 19415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) UpdateSparseEntry(); 19425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 19435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 19445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlyUpdateSparseEntry) { 19455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 19465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetCacheType(net::MEDIA_CACHE); 19475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 19485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) UpdateSparseEntry(); 19495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 19505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 19515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::DoomSparseEntry() { 19525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key1("the first key"); 19535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key2("the second key"); 19545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry *entry1, *entry2; 19555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key1, &entry1)); 19565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key2, &entry2)); 19575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 19585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize = 4 * 1024; 19595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize)); 19605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buf->data(), kSize, false); 19615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 19625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int64 offset = 1024; 19635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Write to a bunch of ranges. 19645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) for (int i = 0; i < 12; i++) { 1965868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, 1966868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry1->WriteSparseData( 1967868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) offset, buf.get(), kSize, net::CompletionCallback())); 19685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Keep the second map under the default size. 19695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (i < 9) { 1970868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, 1971868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry2->WriteSparseData( 1972868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) offset, buf.get(), kSize, net::CompletionCallback())); 19735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 19745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 19755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) offset *= 4; 19765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 19775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 19785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (memory_only_) 19795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(2, cache_->GetEntryCount()); 19805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) else 19815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(15, cache_->GetEntryCount()); 19825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 19835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Doom the first entry while it's still open. 19845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry1->Doom(); 19855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry1->Close(); 19865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry2->Close(); 19875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 19885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Doom the second entry after it's fully saved. 19895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(net::OK, DoomEntry(key2)); 19905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 19915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Make sure we do all needed work. This may fail for entry2 if between Close 19925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // and DoomEntry the system decides to remove all traces of the file from the 19935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // system cache so we don't see that there is pending IO. 199490dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) base::MessageLoop::current()->RunUntilIdle(); 19955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 19965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (memory_only_) { 19975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, cache_->GetEntryCount()); 19985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } else { 19995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (5 == cache_->GetEntryCount()) { 20005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Most likely we are waiting for the result of reading the sparse info 20015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // (it's always async on Posix so it is easy to miss). Unfortunately we 20025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // don't have any signal to watch for so we can only wait. 20035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(500)); 200490dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) base::MessageLoop::current()->RunUntilIdle(); 20055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 20065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, cache_->GetEntryCount()); 20075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 20085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 20095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 20105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, DoomSparseEntry) { 20115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) UseCurrentThread(); 20125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 20135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DoomSparseEntry(); 20145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 20155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 20165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryOnlyDoomSparseEntry) { 20175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 20185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 20195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DoomSparseEntry(); 20205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 20215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 20225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// A CompletionCallback wrapper that deletes the cache from within the callback. 20235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// The way a CompletionCallback works means that all tasks (even new ones) 20245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// are executed by the message loop before returning to the caller so the only 20255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// way to simulate a race is to execute what we want on the callback. 20265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class SparseTestCompletionCallback: public net::TestCompletionCallback { 20275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) public: 2028a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) explicit SparseTestCompletionCallback(scoped_ptr<disk_cache::Backend> cache) 2029a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) : cache_(cache.Pass()) { 20305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 20315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 20325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) private: 20335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) virtual void SetResult(int result) OVERRIDE { 2034a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) cache_.reset(); 20355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) TestCompletionCallback::SetResult(result); 20365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 20375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2038a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) scoped_ptr<disk_cache::Backend> cache_; 20395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DISALLOW_COPY_AND_ASSIGN(SparseTestCompletionCallback); 20405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)}; 20415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 20425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Tests that we don't crash when the backend is deleted while we are working 20435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// deleting the sub-entries of a sparse entry. 20445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, DoomSparseEntry2) { 20455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) UseCurrentThread(); 20465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 20475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key("the key"); 20485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 20495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 20505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 20515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize = 4 * 1024; 20525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize)); 20535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buf->data(), kSize, false); 20545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 20555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int64 offset = 1024; 20565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Write to a bunch of ranges. 20575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) for (int i = 0; i < 12; i++) { 2058868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, 2059868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->WriteSparseData( 2060868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) offset, buf.get(), kSize, net::CompletionCallback())); 20615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) offset *= 4; 20625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 20635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(9, cache_->GetEntryCount()); 20645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 20655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 2066a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) disk_cache::Backend* cache = cache_.get(); 2067a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) SparseTestCompletionCallback cb(cache_.Pass()); 2068a36e5920737c6adbddd3e43b760e5de8431db6e0Torne (Richard Coles) int rv = cache->DoomEntry(key, cb.callback()); 20695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(net::ERR_IO_PENDING, rv); 20705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(net::OK, cb.WaitForResult()); 20715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 20725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 20735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void DiskCacheEntryTest::PartialSparseEntry() { 20745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key("the first key"); 20755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 20765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 20775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 20785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // We should be able to deal with IO that is not aligned to the block size 20795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // of a sparse entry, at least to write a big range without leaving holes. 20805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize = 4 * 1024; 20815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSmallSize = 128; 20825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buf1(new net::IOBuffer(kSize)); 20835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buf1->data(), kSize, false); 20845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 20855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // The first write is just to extend the entry. The third write occupies 20865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // a 1KB block partially, it may not be written internally depending on the 20875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // implementation. 2088868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteSparseData(entry, 20000, buf1.get(), kSize)); 2089868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteSparseData(entry, 500, buf1.get(), kSize)); 2090868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSmallSize, 2091868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) WriteSparseData(entry, 1080321, buf1.get(), kSmallSize)); 20925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 20935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key, &entry)); 20945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 20955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buf2(new net::IOBuffer(kSize)); 20965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) memset(buf2->data(), 0, kSize); 2097868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(0, ReadSparseData(entry, 8000, buf2.get(), kSize)); 20985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2099868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(500, ReadSparseData(entry, kSize, buf2.get(), kSize)); 21005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, memcmp(buf2->data(), buf1->data() + kSize - 500, 500)); 2101868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(0, ReadSparseData(entry, 0, buf2.get(), kSize)); 21025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 21035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // This read should not change anything. 2104868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(96, ReadSparseData(entry, 24000, buf2.get(), kSize)); 2105868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(500, ReadSparseData(entry, kSize, buf2.get(), kSize)); 2106868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(0, ReadSparseData(entry, 99, buf2.get(), kSize)); 21075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 21085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int rv; 21095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int64 start; 21105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) net::TestCompletionCallback cb; 21115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (memory_only_) { 21125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) rv = entry->GetAvailableRange(0, 600, &start, cb.callback()); 21135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(100, cb.GetResult(rv)); 21145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(500, start); 21155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } else { 21165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) rv = entry->GetAvailableRange(0, 2048, &start, cb.callback()); 21175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(1024, cb.GetResult(rv)); 21185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(1024, start); 21195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 21205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) rv = entry->GetAvailableRange(kSize, kSize, &start, cb.callback()); 21215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(500, cb.GetResult(rv)); 21225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(kSize, start); 21235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) rv = entry->GetAvailableRange(20 * 1024, 10000, &start, cb.callback()); 21245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(3616, cb.GetResult(rv)); 21255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(20 * 1024, start); 21265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 21275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // 1. Query before a filled 1KB block. 21285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // 2. Query within a filled 1KB block. 21295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // 3. Query beyond a filled 1KB block. 21305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (memory_only_) { 21315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) rv = entry->GetAvailableRange(19400, kSize, &start, cb.callback()); 21325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(3496, cb.GetResult(rv)); 21335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(20000, start); 21345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } else { 21355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) rv = entry->GetAvailableRange(19400, kSize, &start, cb.callback()); 21365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(3016, cb.GetResult(rv)); 21375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(20480, start); 21385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 21395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) rv = entry->GetAvailableRange(3073, kSize, &start, cb.callback()); 21405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(1523, cb.GetResult(rv)); 21415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(3073, start); 21425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) rv = entry->GetAvailableRange(4600, kSize, &start, cb.callback()); 21435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, cb.GetResult(rv)); 21445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(4600, start); 21455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 21465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Now make another write and verify that there is no hole in between. 2147868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteSparseData(entry, 500 + kSize, buf1.get(), kSize)); 21485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) rv = entry->GetAvailableRange(1024, 10000, &start, cb.callback()); 21495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(7 * 1024 + 500, cb.GetResult(rv)); 21505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(1024, start); 2151868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, ReadSparseData(entry, kSize, buf2.get(), kSize)); 21525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, memcmp(buf2->data(), buf1->data() + kSize - 500, 500)); 21535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, memcmp(buf2->data() + 500, buf1->data(), kSize - 500)); 21545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 21555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 21565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 21575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 21585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, PartialSparseEntry) { 21595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 21605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PartialSparseEntry(); 21615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 21625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 21635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, MemoryPartialSparseEntry) { 21645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SetMemoryOnlyMode(); 21655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 21665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PartialSparseEntry(); 21675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 21685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 21695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Tests that corrupt sparse children are removed automatically. 21705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, CleanupSparseEntry) { 21715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 21725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key("the first key"); 21735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 21745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 21755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 21765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize = 4 * 1024; 21775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buf1(new net::IOBuffer(kSize)); 21785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buf1->data(), kSize, false); 21795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 21805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int k1Meg = 1024 * 1024; 2181868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteSparseData(entry, 8192, buf1.get(), kSize)); 2182868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteSparseData(entry, k1Meg + 8192, buf1.get(), kSize)); 2183868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteSparseData(entry, 2 * k1Meg + 8192, buf1.get(), kSize)); 21845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 21855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(4, cache_->GetEntryCount()); 21865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 21875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void* iter = NULL; 21885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int count = 0; 21895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string child_key[2]; 21905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) while (OpenNextEntry(&iter, &entry) == net::OK) { 21915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_TRUE(entry != NULL); 21925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Writing to an entry will alter the LRU list and invalidate the iterator. 21935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (entry->GetKey() != key && count < 2) 21945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) child_key[count++] = entry->GetKey(); 21955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 21965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 21975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) for (int i = 0; i < 2; i++) { 21985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(child_key[i], &entry)); 21995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Overwrite the header's magic and signature. 2200868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(12, WriteData(entry, 2, 0, buf1.get(), 12, false)); 22015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 22025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 22035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 22045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(4, cache_->GetEntryCount()); 22055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key, &entry)); 22065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 22075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Two children should be gone. One while reading and one while writing. 2208868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(0, ReadSparseData(entry, 2 * k1Meg + 8192, buf1.get(), kSize)); 2209868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, WriteSparseData(entry, k1Meg + 16384, buf1.get(), kSize)); 2210868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(0, ReadSparseData(entry, k1Meg + 8192, buf1.get(), kSize)); 22115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 22125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // We never touched this one. 2213868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize, ReadSparseData(entry, 8192, buf1.get(), kSize)); 22145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 22155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 22165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // We re-created one of the corrupt children. 22175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(3, cache_->GetEntryCount()); 22185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 22195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 22205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, CancelSparseIO) { 22215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) UseCurrentThread(); 22225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 22235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key("the first key"); 22245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 22255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 22265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 22275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const int kSize = 40 * 1024; 22285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize)); 22295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CacheTestFillBuffer(buf->data(), kSize, false); 22305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 22315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // This will open and write two "real" entries. 22325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) net::TestCompletionCallback cb1, cb2, cb3, cb4, cb5; 22335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int rv = entry->WriteSparseData( 2234868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1024 * 1024 - 4096, buf.get(), kSize, cb1.callback()); 22355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(net::ERR_IO_PENDING, rv); 22365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 22375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int64 offset = 0; 22385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) rv = entry->GetAvailableRange(offset, kSize, &offset, cb5.callback()); 22395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) rv = cb5.GetResult(rv); 22405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (!cb1.have_result()) { 22415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // We may or may not have finished writing to the entry. If we have not, 22425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // we cannot start another operation at this time. 22435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED, rv); 22445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 22455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 22465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // We cancel the pending operation, and register multiple notifications. 22475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->CancelSparseIO(); 22485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadyForSparseIO(cb2.callback())); 22495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadyForSparseIO(cb3.callback())); 22505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->CancelSparseIO(); // Should be a no op at this point. 22515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadyForSparseIO(cb4.callback())); 22525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 22535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (!cb1.have_result()) { 22545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED, 2255868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->ReadSparseData( 2256868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) offset, buf.get(), kSize, net::CompletionCallback())); 22575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED, 2258868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->WriteSparseData( 2259868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) offset, buf.get(), kSize, net::CompletionCallback())); 22605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 22615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 22625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Now see if we receive all notifications. Note that we should not be able 22635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // to write everything (unless the timing of the system is really weird). 22645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) rv = cb1.WaitForResult(); 22655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_TRUE(rv == 4096 || rv == kSize); 22665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(net::OK, cb2.WaitForResult()); 22675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(net::OK, cb3.WaitForResult()); 22685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(net::OK, cb4.WaitForResult()); 22695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 22705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) rv = entry->GetAvailableRange(offset, kSize, &offset, cb5.callback()); 22715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EXPECT_EQ(0, cb5.GetResult(rv)); 22725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 22735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 22745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 22755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Tests that we perform sanity checks on an entry's key. Note that there are 22765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// other tests that exercise sanity checks by using saved corrupt files. 22775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TEST_F(DiskCacheEntryTest, KeySanityCheck) { 22785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) UseCurrentThread(); 22795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitCache(); 22805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string key("the first key"); 22815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::Entry* entry; 22825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 22835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 22845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::EntryImpl* entry_impl = 22855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) static_cast<disk_cache::EntryImpl*>(entry); 22865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) disk_cache::EntryStore* store = entry_impl->entry()->Data(); 22875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 22885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // We have reserved space for a short key (one block), let's say that the key 22895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // takes more than one block, and remove the NULLs after the actual key. 22905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) store->key_len = 800; 22915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) memset(store->key + key.size(), 'k', sizeof(store->key) - key.size()); 22925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry_impl->entry()->set_modified(); 22935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) entry->Close(); 22945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 22955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // We have a corrupt entry. Now reload it. We should NOT read beyond the 22965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // allocated buffer here. 22975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ASSERT_NE(net::OK, OpenEntry(key, &entry)); 22985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DisableIntegrityCheck(); 22995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 2300c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2301c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// The simple cache backend isn't intended to work on Windows, which has very 2302c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// different file system guarantees from Linux. 2303c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)#if defined(OS_POSIX) 2304c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2305c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheInternalAsyncIO) { 2306c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2307c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2308c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InternalAsyncIO(); 2309c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2310c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2311c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheExternalAsyncIO) { 2312c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2313c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2314c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ExternalAsyncIO(); 2315c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2316c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2317c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheReleaseBuffer) { 2318c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2319c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2320c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ReleaseBuffer(); 2321c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2322c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2323c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheStreamAccess) { 2324c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2325c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2326c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) StreamAccess(); 2327c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2328c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2329c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheGetKey) { 2330c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2331c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2332c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) GetKey(); 2333c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2334c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2335c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheGetTimes) { 2336c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2337c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2338c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) GetTimes(); 2339c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2340c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2341c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheGrowData) { 2342c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2343c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2344c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) GrowData(); 2345c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2346c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2347c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheTruncateData) { 2348c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2349c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2350c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) TruncateData(); 2351c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2352c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2353c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheZeroLengthIO) { 2354c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2355c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2356c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ZeroLengthIO(); 2357c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2358c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2359c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheSizeAtCreate) { 2360c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2361c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2362c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SizeAtCreate(); 2363c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2364c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2365c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheReuseExternalEntry) { 2366c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2367c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetMaxSize(200 * 1024); 2368c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2369c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ReuseEntry(20 * 1024); 2370c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2371c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2372c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheReuseInternalEntry) { 2373c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2374c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetMaxSize(100 * 1024); 2375c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2376c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ReuseEntry(10 * 1024); 2377c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2378c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2379c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheSizeChanges) { 2380c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2381c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2382c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SizeChanges(); 2383c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2384c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2385c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheInvalidData) { 2386c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2387c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2388c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InvalidData(); 2389c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2390c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2391c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheReadWriteDestroyBuffer) { 2392c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2393c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2394c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ReadWriteDestroyBuffer(); 2395c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2396c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2397c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheDoomEntry) { 2398c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2399c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2400c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) DoomNormalEntry(); 2401c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2402c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2403c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheDoomEntryNextToOpenEntry) { 2404c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2405c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2406c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) DoomEntryNextToOpenEntry(); 2407c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2408c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2409c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheDoomedEntry) { 2410c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2411c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2412c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) DoomedEntry(); 2413c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2414c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2415868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)// Creates an entry with corrupted last byte in stream 0. 2416868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)// Requires SimpleCacheMode. 2417868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)bool DiskCacheEntryTest::SimpleCacheMakeBadChecksumEntry(const char* key, 2418868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) int* data_size) { 2419c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* entry = NULL; 2420c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2421868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) if (CreateEntry(key, &entry) != net::OK || !entry) { 2422868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) LOG(ERROR) << "Could not create entry"; 2423868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) return false; 2424868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) } 2425c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2426868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) const char data[] = "this is very good data"; 2427868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) const int kDataSize = arraysize(data); 2428868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kDataSize)); 2429868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) base::strlcpy(buffer->data(), data, kDataSize); 2430c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2431868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kDataSize, WriteData(entry, 0, 0, buffer.get(), kDataSize, false)); 2432c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) entry->Close(); 2433c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) entry = NULL; 2434c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2435868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Corrupt the last byte of the data. 2436c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) base::FilePath entry_file0_path = cache_path_.AppendASCII( 2437c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::simple_util::GetFilenameFromKeyAndIndex(key, 0)); 2438c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) int flags = base::PLATFORM_FILE_WRITE | base::PLATFORM_FILE_OPEN; 2439c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) base::PlatformFile entry_file0 = 2440c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) base::CreatePlatformFile(entry_file0_path, flags, NULL, NULL); 2441868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) if (entry_file0 == base::kInvalidPlatformFileValue) 2442868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) return false; 2443c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) int64 file_offset = 2444868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) disk_cache::simple_util::GetFileOffsetFromKeyAndDataOffset( 2445868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) key, kDataSize - 2); 2446868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(1, base::WritePlatformFile(entry_file0, file_offset, "X", 1)); 2447868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) if (!base::ClosePlatformFile(entry_file0)) 2448868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) return false; 2449868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) *data_size = kDataSize; 2450868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) return true; 2451c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2452c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2453c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// Tests that the simple cache can detect entries that have bad data. 2454c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheBadChecksum) { 2455c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2456c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2457c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2458c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const char key[] = "the first key"; 2459868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) int size_unused; 2460868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ASSERT_TRUE(SimpleCacheMakeBadChecksumEntry(key, &size_unused)); 2461c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2462c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* entry = NULL; 2463c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2464c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Open the entry. 2465868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key, &entry)); 2466bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ScopedEntryPtr entry_closer(entry); 2467c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2468c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const int kReadBufferSize = 200; 2469868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_GE(kReadBufferSize, entry->GetDataSize(0)); 2470c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kReadBufferSize)); 247190dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) EXPECT_EQ(net::ERR_CACHE_CHECKSUM_MISMATCH, 2472868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ReadData(entry, 0, 0, read_buffer.get(), kReadBufferSize)); 2473c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2474c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2475c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// Tests that an entry that has had an IO error occur can still be Doomed(). 2476c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheErrorThenDoom) { 2477c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2478c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2479c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2480c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const char key[] = "the first key"; 2481868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) int size_unused; 2482868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ASSERT_TRUE(SimpleCacheMakeBadChecksumEntry(key, &size_unused)); 2483c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2484c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* entry = NULL; 2485c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2486c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Open the entry, forcing an IO error. 2487868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key, &entry)); 2488bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ScopedEntryPtr entry_closer(entry); 2489c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2490c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const int kReadBufferSize = 200; 2491868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_GE(kReadBufferSize, entry->GetDataSize(0)); 2492c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kReadBufferSize)); 249390dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) EXPECT_EQ(net::ERR_CACHE_CHECKSUM_MISMATCH, 2494868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ReadData(entry, 0, 0, read_buffer.get(), kReadBufferSize)); 2495c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2496c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) entry->Doom(); // Should not crash. 2497c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2498c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2499c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)bool TruncatePath(const base::FilePath& file_path, int64 length) { 2500c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const int flags = base::PLATFORM_FILE_WRITE | base::PLATFORM_FILE_OPEN; 2501c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) base::PlatformFile file = 2502c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) base::CreatePlatformFile(file_path, flags, NULL, NULL); 2503c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) if (base::kInvalidPlatformFileValue == file) 2504c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) return false; 2505c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const bool result = base::TruncatePlatformFile(file, length); 2506c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) base::ClosePlatformFile(file); 2507c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) return result; 2508c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2509c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2510c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheNoEOF) { 2511c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2512c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2513c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2514c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const char key[] = "the first key"; 2515c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2516c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* entry = NULL; 2517c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 2518c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* null = NULL; 2519c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_NE(null, entry); 2520c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) entry->Close(); 2521c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) entry = NULL; 2522c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2523c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Force the entry to flush to disk, so subsequent platform file operations 2524c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // succed. 2525c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key, &entry)); 2526c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) entry->Close(); 2527c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) entry = NULL; 2528c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2529c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Truncate the file such that the length isn't sufficient to have an EOF 2530c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // record. 2531c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) int kTruncationBytes = -implicit_cast<int>(sizeof(disk_cache::SimpleFileEOF)); 2532c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const base::FilePath entry_path = cache_path_.AppendASCII( 2533c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::simple_util::GetFilenameFromKeyAndIndex(key, 0)); 2534c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const int64 invalid_size = 2535c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::simple_util::GetFileSizeFromKeyAndDataSize(key, 2536c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) kTruncationBytes); 2537c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_TRUE(TruncatePath(entry_path, invalid_size)); 2538c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_EQ(net::ERR_FAILED, OpenEntry(key, &entry)); 2539c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) DisableIntegrityCheck(); 2540c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2541c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2542bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben MurdochTEST_F(DiskCacheEntryTest, SimpleCacheNonOptimisticOperationsBasic) { 2543bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch // Test sequence: 2544bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch // Create, Write, Read, Close. 2545bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch SetCacheType(net::APP_CACHE); // APP_CACHE doesn't use optimistic operations. 2546bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch SetSimpleCacheMode(); 2547bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch InitCache(); 2548bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch disk_cache::Entry* const null_entry = NULL; 2549bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch 2550bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch disk_cache::Entry* entry = NULL; 2551bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch EXPECT_EQ(net::OK, CreateEntry("my key", &entry)); 2552bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ASSERT_NE(null_entry, entry); 2553bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ScopedEntryPtr entry_closer(entry); 2554bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch 2555bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch const int kBufferSize = 10; 2556bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch scoped_refptr<net::IOBufferWithSize> write_buffer( 2557bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch new net::IOBufferWithSize(kBufferSize)); 2558bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch CacheTestFillBuffer(write_buffer->data(), write_buffer->size(), false); 2559bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch EXPECT_EQ( 2560bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch write_buffer->size(), 2561bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch WriteData(entry, 0, 0, write_buffer.get(), write_buffer->size(), false)); 2562bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch 2563bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch scoped_refptr<net::IOBufferWithSize> read_buffer( 2564bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch new net::IOBufferWithSize(kBufferSize)); 2565bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch EXPECT_EQ( 2566bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch read_buffer->size(), 2567bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ReadData(entry, 0, 0, read_buffer.get(), read_buffer->size())); 2568bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch} 2569bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch 2570bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben MurdochTEST_F(DiskCacheEntryTest, SimpleCacheNonOptimisticOperationsDontBlock) { 2571bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch // Test sequence: 2572bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch // Create, Write, Close. 2573bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch SetCacheType(net::APP_CACHE); // APP_CACHE doesn't use optimistic operations. 2574bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch SetSimpleCacheMode(); 2575bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch InitCache(); 2576bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch disk_cache::Entry* const null_entry = NULL; 2577bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch 2578bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch MessageLoopHelper helper; 2579bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch CallbackTest create_callback(&helper, false); 2580bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch 2581bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch int expected_callback_runs = 0; 2582bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch const int kBufferSize = 10; 2583bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch scoped_refptr<net::IOBufferWithSize> write_buffer( 2584bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch new net::IOBufferWithSize(kBufferSize)); 2585bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch 2586bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch disk_cache::Entry* entry = NULL; 2587bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch EXPECT_EQ(net::OK, CreateEntry("my key", &entry)); 2588bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ASSERT_NE(null_entry, entry); 2589bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ScopedEntryPtr entry_closer(entry); 2590bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch 2591bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch CacheTestFillBuffer(write_buffer->data(), write_buffer->size(), false); 2592bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch CallbackTest write_callback(&helper, false); 2593bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch int ret = entry->WriteData( 2594bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch 0, 2595bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch 0, 2596bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch write_buffer.get(), 2597bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch write_buffer->size(), 2598bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch base::Bind(&CallbackTest::Run, base::Unretained(&write_callback)), 2599bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch false); 2600bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ASSERT_EQ(net::ERR_IO_PENDING, ret); 2601bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch helper.WaitUntilCacheIoFinished(++expected_callback_runs); 2602bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch} 2603bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch 2604bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben MurdochTEST_F(DiskCacheEntryTest, 2605bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch SimpleCacheNonOptimisticOperationsBasicsWithoutWaiting) { 2606bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch // Test sequence: 2607bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch // Create, Write, Read, Close. 2608bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch SetCacheType(net::APP_CACHE); // APP_CACHE doesn't use optimistic operations. 2609bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch SetSimpleCacheMode(); 2610bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch InitCache(); 2611bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch disk_cache::Entry* const null_entry = NULL; 2612bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch MessageLoopHelper helper; 2613bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch 2614bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch disk_cache::Entry* entry = NULL; 2615bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch // Note that |entry| is only set once CreateEntry() completed which is why we 2616bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch // have to wait (i.e. use the helper CreateEntry() function). 2617bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch EXPECT_EQ(net::OK, CreateEntry("my key", &entry)); 2618bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ASSERT_NE(null_entry, entry); 2619bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ScopedEntryPtr entry_closer(entry); 2620bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch 2621bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch const int kBufferSize = 10; 2622bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch scoped_refptr<net::IOBufferWithSize> write_buffer( 2623bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch new net::IOBufferWithSize(kBufferSize)); 2624bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch CacheTestFillBuffer(write_buffer->data(), write_buffer->size(), false); 2625bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch CallbackTest write_callback(&helper, false); 2626bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch int ret = entry->WriteData( 2627bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch 0, 2628bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch 0, 2629bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch write_buffer.get(), 2630bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch write_buffer->size(), 2631bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch base::Bind(&CallbackTest::Run, base::Unretained(&write_callback)), 2632bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch false); 2633bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch EXPECT_EQ(net::ERR_IO_PENDING, ret); 2634bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch int expected_callback_runs = 1; 2635bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch 2636bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch scoped_refptr<net::IOBufferWithSize> read_buffer( 2637bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch new net::IOBufferWithSize(kBufferSize)); 2638bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch CallbackTest read_callback(&helper, false); 2639bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ret = entry->ReadData( 2640bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch 0, 2641bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch 0, 2642bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch read_buffer.get(), 2643bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch read_buffer->size(), 2644bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch base::Bind(&CallbackTest::Run, base::Unretained(&read_callback))); 2645bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch EXPECT_EQ(net::ERR_IO_PENDING, ret); 2646bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ++expected_callback_runs; 2647bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch 2648bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch helper.WaitUntilCacheIoFinished(expected_callback_runs); 2649bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ASSERT_EQ(read_buffer->size(), write_buffer->size()); 2650bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch EXPECT_EQ( 2651bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch 0, 2652bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch memcmp(read_buffer->data(), write_buffer->data(), read_buffer->size())); 2653bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch} 2654bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch 2655c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic) { 2656c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Test sequence: 2657c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Create, Write, Read, Write, Read, Close. 2658c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2659c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2660c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* null = NULL; 2661c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const char key[] = "the first key"; 2662c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2663c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) MessageLoopHelper helper; 2664c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) CallbackTest callback1(&helper, false); 2665c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) CallbackTest callback2(&helper, false); 2666c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) CallbackTest callback3(&helper, false); 2667c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) CallbackTest callback4(&helper, false); 2668c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) CallbackTest callback5(&helper, false); 2669c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2670c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) int expected = 0; 2671c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const int kSize1 = 10; 2672c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const int kSize2 = 20; 2673c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1)); 2674c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) scoped_refptr<net::IOBuffer> buffer1_read(new net::IOBuffer(kSize1)); 2675c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize2)); 2676c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) scoped_refptr<net::IOBuffer> buffer2_read(new net::IOBuffer(kSize2)); 2677c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) CacheTestFillBuffer(buffer1->data(), kSize1, false); 2678c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) CacheTestFillBuffer(buffer2->data(), kSize2, false); 2679c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2680c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* entry = NULL; 2681c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Create is optimistic, must return OK. 2682c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ASSERT_EQ(net::OK, 2683c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) cache_->CreateEntry(key, &entry, 2684c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) base::Bind(&CallbackTest::Run, 2685c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) base::Unretained(&callback1)))); 2686c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_NE(null, entry); 2687bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ScopedEntryPtr entry_closer(entry); 2688c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2689c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // This write may or may not be optimistic (it depends if the previous 2690c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // optimistic create already finished by the time we call the write here). 2691c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) int ret = entry->WriteData( 2692868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 2693868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 2694868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer1.get(), 2695868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kSize1, 2696868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback2)), 2697868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) false); 2698c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_TRUE(kSize1 == ret || net::ERR_IO_PENDING == ret); 2699c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) if (net::ERR_IO_PENDING == ret) 2700c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) expected++; 2701c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2702c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // This Read must not be optimistic, since we don't support that yet. 2703868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(net::ERR_IO_PENDING, 2704868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->ReadData( 2705868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 2706868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 2707868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer1_read.get(), 2708868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kSize1, 2709868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback3)))); 2710c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) expected++; 2711c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); 2712c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_EQ(0, memcmp(buffer1->data(), buffer1_read->data(), kSize1)); 2713c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2714c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // At this point after waiting, the pending operations queue on the entry 2715c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // should be empty, so the next Write operation must run as optimistic. 2716c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_EQ(kSize2, 2717c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) entry->WriteData( 2718868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 2719868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 2720868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer2.get(), 2721868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kSize2, 2722868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback4)), 2723868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) false)); 2724c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2725c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Lets do another read so we block until both the write and the read 2726c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // operation finishes and we can then test for HasOneRef() below. 2727868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(net::ERR_IO_PENDING, 2728868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->ReadData( 2729868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 2730868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 2731868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buffer2_read.get(), 2732868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kSize2, 2733868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) base::Bind(&CallbackTest::Run, base::Unretained(&callback5)))); 2734c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) expected++; 2735c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2736c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); 2737c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_EQ(0, memcmp(buffer2->data(), buffer2_read->data(), kSize2)); 2738c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2739c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Check that we are not leaking. 2740c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_NE(entry, null); 2741c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_TRUE( 2742c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef()); 2743c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2744c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2745c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic2) { 2746c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Test sequence: 2747c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Create, Open, Close, Close. 2748c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2749c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2750c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* null = NULL; 2751c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const char key[] = "the first key"; 2752c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2753c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) MessageLoopHelper helper; 2754c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) CallbackTest callback1(&helper, false); 2755c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) CallbackTest callback2(&helper, false); 2756c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2757c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* entry = NULL; 2758c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ASSERT_EQ(net::OK, 2759c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) cache_->CreateEntry(key, &entry, 2760c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) base::Bind(&CallbackTest::Run, 2761c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) base::Unretained(&callback1)))); 2762c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_NE(null, entry); 2763bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ScopedEntryPtr entry_closer(entry); 2764c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2765c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* entry2 = NULL; 2766868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ASSERT_EQ(net::ERR_IO_PENDING, 2767c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) cache_->OpenEntry(key, &entry2, 2768c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) base::Bind(&CallbackTest::Run, 2769c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) base::Unretained(&callback2)))); 2770868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ASSERT_TRUE(helper.WaitUntilCacheIoFinished(1)); 2771c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2772c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_NE(null, entry2); 2773c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_EQ(entry, entry2); 2774c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2775c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // We have to call close twice, since we called create and open above. 2776c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) entry->Close(); 2777c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2778c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Check that we are not leaking. 2779c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_TRUE( 2780c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef()); 2781c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2782c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2783c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic3) { 2784c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Test sequence: 2785c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Create, Close, Open, Close. 2786c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2787c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2788c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* null = NULL; 2789c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const char key[] = "the first key"; 2790c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2791c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* entry = NULL; 2792c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ASSERT_EQ(net::OK, 2793c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) cache_->CreateEntry(key, &entry, net::CompletionCallback())); 2794c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_NE(null, entry); 2795c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) entry->Close(); 2796c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2797c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) net::TestCompletionCallback cb; 2798c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* entry2 = NULL; 2799868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ASSERT_EQ(net::ERR_IO_PENDING, 2800c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) cache_->OpenEntry(key, &entry2, cb.callback())); 2801868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ASSERT_EQ(net::OK, cb.GetResult(net::ERR_IO_PENDING)); 2802bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ScopedEntryPtr entry_closer(entry2); 2803c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2804c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_NE(null, entry2); 2805c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_EQ(entry, entry2); 2806c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2807c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Check that we are not leaking. 2808c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_TRUE( 2809c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) static_cast<disk_cache::SimpleEntryImpl*>(entry2)->HasOneRef()); 2810c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2811c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2812c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic4) { 2813c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Test sequence: 2814c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Create, Close, Write, Open, Open, Close, Write, Read, Close. 2815c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2816c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2817c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* null = NULL; 2818c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const char key[] = "the first key"; 2819c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2820c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) net::TestCompletionCallback cb; 2821c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const int kSize1 = 10; 2822c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1)); 2823c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) CacheTestFillBuffer(buffer1->data(), kSize1, false); 2824c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* entry = NULL; 2825c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2826c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ASSERT_EQ(net::OK, 2827c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) cache_->CreateEntry(key, &entry, net::CompletionCallback())); 2828c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_NE(null, entry); 2829c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) entry->Close(); 2830c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2831c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Lets do a Write so we block until both the Close and the Write 2832c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // operation finishes. Write must fail since we are writing in a closed entry. 2833868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ( 2834868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) net::ERR_IO_PENDING, 2835868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->WriteData(0, 0, buffer1.get(), kSize1, cb.callback(), false)); 2836c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_EQ(net::ERR_FAILED, cb.GetResult(net::ERR_IO_PENDING)); 2837c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2838c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Finish running the pending tasks so that we fully complete the close 2839c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // operation and destroy the entry object. 284090dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) base::MessageLoop::current()->RunUntilIdle(); 2841c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2842c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // At this point the |entry| must have been destroyed, and called 2843c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // RemoveSelfFromBackend(). 2844c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* entry2 = NULL; 2845868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ASSERT_EQ(net::ERR_IO_PENDING, 2846c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) cache_->OpenEntry(key, &entry2, cb.callback())); 2847868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ASSERT_EQ(net::OK, cb.GetResult(net::ERR_IO_PENDING)); 2848c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_NE(null, entry2); 2849c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2850c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* entry3 = NULL; 2851868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ASSERT_EQ(net::ERR_IO_PENDING, 2852c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) cache_->OpenEntry(key, &entry3, cb.callback())); 2853868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ASSERT_EQ(net::OK, cb.GetResult(net::ERR_IO_PENDING)); 2854c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_NE(null, entry3); 2855c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_EQ(entry2, entry3); 2856c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) entry3->Close(); 2857c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2858c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // The previous Close doesn't actually closes the entry since we opened it 2859c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // twice, so the next Write operation must succeed and it must be able to 2860c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // perform it optimistically, since there is no operation running on this 2861c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // entry. 2862868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kSize1, 2863868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry2->WriteData( 2864868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 0, buffer1.get(), kSize1, net::CompletionCallback(), false)); 2865c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2866c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Lets do another read so we block until both the write and the read 2867c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // operation finishes and we can then test for HasOneRef() below. 2868868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(net::ERR_IO_PENDING, 2869868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry2->ReadData(0, 0, buffer1.get(), kSize1, cb.callback())); 2870c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING)); 2871c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2872c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Check that we are not leaking. 2873c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_TRUE( 2874c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) static_cast<disk_cache::SimpleEntryImpl*>(entry2)->HasOneRef()); 2875c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) entry2->Close(); 2876c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2877c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2878c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// This test is flaky because of the race of Create followed by a Doom. 2879c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// See test SimpleCacheCreateDoomRace. 2880c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, DISABLED_SimpleCacheOptimistic5) { 2881c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Test sequence: 2882c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Create, Doom, Write, Read, Close. 2883c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2884c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2885c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* null = NULL; 2886c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const char key[] = "the first key"; 2887c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2888c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) net::TestCompletionCallback cb; 2889c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const int kSize1 = 10; 2890c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1)); 2891c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) CacheTestFillBuffer(buffer1->data(), kSize1, false); 2892c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* entry = NULL; 2893c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2894c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ASSERT_EQ(net::OK, 2895c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) cache_->CreateEntry(key, &entry, net::CompletionCallback())); 2896c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_NE(null, entry); 2897bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ScopedEntryPtr entry_closer(entry); 2898c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) entry->Doom(); 2899c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2900868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ( 2901868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) net::ERR_IO_PENDING, 2902868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->WriteData(0, 0, buffer1.get(), kSize1, cb.callback(), false)); 2903c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING)); 2904c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2905868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(net::ERR_IO_PENDING, 2906868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->ReadData(0, 0, buffer1.get(), kSize1, cb.callback())); 2907c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING)); 2908c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2909c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Check that we are not leaking. 2910c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_TRUE( 2911c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef()); 2912c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2913c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2914c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic6) { 2915c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Test sequence: 2916c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Create, Write, Doom, Doom, Read, Doom, Close. 2917c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2918c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2919c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* null = NULL; 2920c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const char key[] = "the first key"; 2921c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2922c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) net::TestCompletionCallback cb; 2923c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const int kSize1 = 10; 2924c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1)); 2925c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) scoped_refptr<net::IOBuffer> buffer1_read(new net::IOBuffer(kSize1)); 2926c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) CacheTestFillBuffer(buffer1->data(), kSize1, false); 2927c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* entry = NULL; 2928c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2929c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ASSERT_EQ(net::OK, 2930c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) cache_->CreateEntry(key, &entry, net::CompletionCallback())); 2931c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_NE(null, entry); 2932bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ScopedEntryPtr entry_closer(entry); 2933c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2934868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ( 2935868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) net::ERR_IO_PENDING, 2936868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->WriteData(0, 0, buffer1.get(), kSize1, cb.callback(), false)); 2937c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING)); 2938c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2939c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) entry->Doom(); 2940c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) entry->Doom(); 2941c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2942c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // This Read must not be optimistic, since we don't support that yet. 2943868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(net::ERR_IO_PENDING, 2944868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->ReadData(0, 0, buffer1_read.get(), kSize1, cb.callback())); 2945c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING)); 2946c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_EQ(0, memcmp(buffer1->data(), buffer1_read->data(), kSize1)); 2947c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2948c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) entry->Doom(); 2949c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2950c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Check that we are not leaking. 2951c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_TRUE( 2952c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef()); 2953c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 2954c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2955868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)// Confirm that IO buffers are not referenced by the Simple Cache after a write 2956868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)// completes. 2957868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheOptimisticWriteReleases) { 2958868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) SetSimpleCacheMode(); 2959868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) InitCache(); 2960868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 2961868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) const char key[] = "the first key"; 2962868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) disk_cache::Entry* entry = NULL; 2963868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 2964868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // First, an optimistic create. 2965868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ASSERT_EQ(net::OK, 2966868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) cache_->CreateEntry(key, &entry, net::CompletionCallback())); 2967868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ASSERT_TRUE(entry); 2968bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ScopedEntryPtr entry_closer(entry); 2969bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch 2970868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) const int kWriteSize = 512; 2971868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kWriteSize)); 2972868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_TRUE(buffer1->HasOneRef()); 2973868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) CacheTestFillBuffer(buffer1->data(), kWriteSize, false); 2974868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 2975868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // An optimistic write happens only when there is an empty queue of pending 2976868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // operations. To ensure the queue is empty, we issue a write and wait until 2977868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // it completes. 2978868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kWriteSize, 29797d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) WriteData(entry, 0, 0, buffer1.get(), kWriteSize, false)); 2980868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_TRUE(buffer1->HasOneRef()); 2981868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 2982868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Finally, we should perform an optimistic write and confirm that all 2983868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // references to the IO buffer have been released. 29847d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) EXPECT_EQ( 29857d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) kWriteSize, 29867d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) entry->WriteData( 29877d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) 1, 0, buffer1.get(), kWriteSize, net::CompletionCallback(), false)); 2988868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_TRUE(buffer1->HasOneRef()); 2989868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)} 2990868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 2991c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, DISABLED_SimpleCacheCreateDoomRace) { 2992c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Test sequence: 2993c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Create, Doom, Write, Close, Check files are not on disk anymore. 2994c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 2995c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 2996c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* null = NULL; 2997c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const char key[] = "the first key"; 2998c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 2999c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) net::TestCompletionCallback cb; 3000c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const int kSize1 = 10; 3001c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1)); 3002c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) CacheTestFillBuffer(buffer1->data(), kSize1, false); 3003c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* entry = NULL; 3004c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 3005c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ASSERT_EQ(net::OK, 3006c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) cache_->CreateEntry(key, &entry, net::CompletionCallback())); 3007c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_NE(null, entry); 3008c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 3009c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) cache_->DoomEntry(key, cb.callback()); 3010c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_EQ(net::OK, cb.GetResult(net::ERR_IO_PENDING)); 3011c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 3012c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Lets do a Write so we block until all operations are done, so we can check 3013c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // the HasOneRef() below. This call can't be optimistic and we are checking 3014c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // that here. 3015868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ( 3016868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) net::ERR_IO_PENDING, 3017868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->WriteData(0, 0, buffer1.get(), kSize1, cb.callback(), false)); 3018c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING)); 3019c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 3020c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Check that we are not leaking. 3021c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_TRUE( 3022c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef()); 3023c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) entry->Close(); 3024c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 3025c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Finish running the pending tasks so that we fully complete the close 3026c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // operation and destroy the entry object. 302790dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) base::MessageLoop::current()->RunUntilIdle(); 3028c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 3029c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) for (int i = 0; i < disk_cache::kSimpleEntryFileCount; ++i) { 3030c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) base::FilePath entry_file_path = cache_path_.AppendASCII( 3031c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::simple_util::GetFilenameFromKeyAndIndex(key, i)); 3032c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) base::PlatformFileInfo info; 3033c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) EXPECT_FALSE(file_util::GetFileInfo(entry_file_path, &info)); 3034c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) } 3035c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 3036c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 303790dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)// Checks that an optimistic Create would fail later on a racing Open. 303890dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheOptimisticCreateFailsOnOpen) { 303990dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) SetSimpleCacheMode(); 304090dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) InitCache(); 304190dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) 30427dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // Create a corrupt file in place of a future entry. Optimistic create should 30437dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // initially succeed, but realize later that creation failed. 30447dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch const std::string key = "the key"; 304590dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) net::TestCompletionCallback cb; 304690dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) disk_cache::Entry* entry = NULL; 304790dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) disk_cache::Entry* entry2 = NULL; 304890dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) 30497dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch EXPECT_TRUE(disk_cache::simple_util::CreateCorruptFileForTests( 30507dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch key, cache_path_)); 305190dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) EXPECT_EQ(net::OK, cache_->CreateEntry(key, &entry, cb.callback())); 30527dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch ASSERT_TRUE(entry); 3053bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ScopedEntryPtr entry_closer(entry); 305490dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) ASSERT_NE(net::OK, OpenEntry(key, &entry2)); 305590dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) 305690dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) // Check that we are not leaking. 305790dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) EXPECT_TRUE( 305890dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef()); 305990dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) 306090dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) DisableIntegrityCheck(); 306190dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)} 306290dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) 3063c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// Tests that old entries are evicted while new entries remain in the index. 3064c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// This test relies on non-mandatory properties of the simple Cache Backend: 3065c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// LRU eviction, specific values of high-watermark and low-watermark etc. 3066c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// When changing the eviction algorithm, the test will have to be re-engineered. 3067c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheEvictOldEntries) { 3068c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const int kMaxSize = 200 * 1024; 3069c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const int kWriteSize = kMaxSize / 10; 3070c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const int kNumExtraEntries = 12; 3071c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetSimpleCacheMode(); 3072c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) SetMaxSize(kMaxSize); 3073c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) InitCache(); 3074c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 3075c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) std::string key1("the first key"); 3076c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) disk_cache::Entry* entry; 3077c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key1, &entry)); 3078c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kWriteSize)); 3079c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) CacheTestFillBuffer(buffer->data(), kWriteSize, false); 3080868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kWriteSize, 3081868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) WriteData(entry, 0, 0, buffer.get(), kWriteSize, false)); 3082c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) entry->Close(); 3083c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 3084c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) std::string key2("the key prefix"); 3085c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) for (int i = 0; i < kNumExtraEntries; i++) { 3086c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key2 + base::StringPrintf("%d", i), &entry)); 3087bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ScopedEntryPtr entry_closer(entry); 3088868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(kWriteSize, 3089868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) WriteData(entry, 0, 0, buffer.get(), kWriteSize, false)); 3090c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) } 3091c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 3092c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // TODO(pasko): Find a way to wait for the eviction task(s) to finish by using 3093c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // the internal knowledge about |SimpleBackendImpl|. 3094c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ASSERT_NE(net::OK, OpenEntry(key1, &entry)) 3095c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) << "Should have evicted the old entry"; 3096c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) for (int i = 0; i < 2; i++) { 3097c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) int entry_no = kNumExtraEntries - i - 1; 3098c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Generally there is no guarantee that at this point the backround eviction 3099c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // is finished. We are testing the positive case, i.e. when the eviction 3100c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // never reaches this entry, should be non-flaky. 3101c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key2 + base::StringPrintf("%d", entry_no), 3102c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) &entry)) 3103c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) << "Should not have evicted fresh entry " << entry_no; 3104c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) entry->Close(); 3105c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) } 3106c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 3107c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 3108a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles)// Tests that if a read and a following in-flight truncate are both in progress 3109a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles)// simultaniously that they both can occur successfully. See 3110a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles)// http://crbug.com/239223 3111a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheInFlightTruncate) { 3112a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) SetSimpleCacheMode(); 3113a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) InitCache(); 3114a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) 3115a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) const char key[] = "the first key"; 3116a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) 3117a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) const int kBufferSize = 1024; 3118a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) scoped_refptr<net::IOBuffer> write_buffer(new net::IOBuffer(kBufferSize)); 3119a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) CacheTestFillBuffer(write_buffer->data(), kBufferSize, false); 3120a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) 3121a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) disk_cache::Entry* entry = NULL; 3122a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 3123a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) 3124a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) EXPECT_EQ(kBufferSize, 3125868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) WriteData(entry, 0, 0, write_buffer.get(), kBufferSize, false)); 3126a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) entry->Close(); 3127a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) entry = NULL; 3128a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) 3129a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key, &entry)); 3130bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ScopedEntryPtr entry_closer(entry); 3131a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) 3132a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) MessageLoopHelper helper; 3133a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) int expected = 0; 3134a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) 3135a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) // Make a short read. 3136a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) const int kReadBufferSize = 512; 3137a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kReadBufferSize)); 3138a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) CallbackTest read_callback(&helper, false); 3139a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) EXPECT_EQ(net::ERR_IO_PENDING, 3140868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->ReadData(0, 3141868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 3142868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) read_buffer.get(), 3143868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kReadBufferSize, 3144a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) base::Bind(&CallbackTest::Run, 3145a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) base::Unretained(&read_callback)))); 3146a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) ++expected; 3147a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) 3148a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) // Truncate the entry to the length of that read. 3149a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) scoped_refptr<net::IOBuffer> 3150a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) truncate_buffer(new net::IOBuffer(kReadBufferSize)); 3151a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) CacheTestFillBuffer(truncate_buffer->data(), kReadBufferSize, false); 3152a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) CallbackTest truncate_callback(&helper, false); 3153a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) EXPECT_EQ(net::ERR_IO_PENDING, 3154868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->WriteData(0, 3155868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 3156868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) truncate_buffer.get(), 3157868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kReadBufferSize, 3158a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) base::Bind(&CallbackTest::Run, 3159a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) base::Unretained(&truncate_callback)), 3160a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) true)); 3161a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) ++expected; 3162a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) 3163a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) // Wait for both the read and truncation to finish, and confirm that both 3164a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) // succeeded. 3165a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); 3166a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) EXPECT_EQ(kReadBufferSize, read_callback.last_result()); 3167a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) EXPECT_EQ(kReadBufferSize, truncate_callback.last_result()); 3168a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) EXPECT_EQ(0, 3169a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) memcmp(write_buffer->data(), read_buffer->data(), kReadBufferSize)); 3170a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles)} 3171a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) 3172a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles)// Tests that if a write and a read dependant on it are both in flight 3173a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles)// simultaneiously that they both can complete successfully without erroneous 3174a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles)// early returns. See http://crbug.com/239223 3175a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheInFlightRead) { 3176a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) SetSimpleCacheMode(); 3177a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) InitCache(); 3178a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) 3179a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) const char key[] = "the first key"; 3180a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) disk_cache::Entry* entry = NULL; 3181a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) ASSERT_EQ(net::OK, 3182a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) cache_->CreateEntry(key, &entry, net::CompletionCallback())); 3183bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ScopedEntryPtr entry_closer(entry); 3184a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) 3185a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) const int kBufferSize = 1024; 3186a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) scoped_refptr<net::IOBuffer> write_buffer(new net::IOBuffer(kBufferSize)); 3187a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) CacheTestFillBuffer(write_buffer->data(), kBufferSize, false); 3188a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) 3189a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) MessageLoopHelper helper; 3190a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) int expected = 0; 3191a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) 3192a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) CallbackTest write_callback(&helper, false); 3193a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) EXPECT_EQ(net::ERR_IO_PENDING, 3194868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->WriteData(0, 3195868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 3196868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) write_buffer.get(), 3197868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kBufferSize, 3198a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) base::Bind(&CallbackTest::Run, 3199a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) base::Unretained(&write_callback)), 3200a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) true)); 3201a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) ++expected; 3202a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) 3203a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kBufferSize)); 3204a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) CallbackTest read_callback(&helper, false); 3205a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) EXPECT_EQ(net::ERR_IO_PENDING, 3206868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->ReadData(0, 3207868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 0, 3208868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) read_buffer.get(), 3209868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) kBufferSize, 3210a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) base::Bind(&CallbackTest::Run, 3211a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) base::Unretained(&read_callback)))); 3212a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) ++expected; 3213a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) 3214a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected)); 3215a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) EXPECT_EQ(kBufferSize, write_callback.last_result()); 3216a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) EXPECT_EQ(kBufferSize, read_callback.last_result()); 3217a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) EXPECT_EQ(0, memcmp(write_buffer->data(), read_buffer->data(), kBufferSize)); 3218a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles)} 3219a93a17c8d99d686bd4a1511e5504e5e6cc9fcadfTorne (Richard Coles) 322090dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheOpenCreateRaceWithNoIndex) { 322190dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) SetSimpleCacheMode(); 32227dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch DisableSimpleCacheWaitForIndex(); 322390dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) DisableIntegrityCheck(); 322490dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) InitCache(); 322590dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) 322690dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) // Assume the index is not initialized, which is likely, since we are blocking 322790dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) // the IO thread from executing the index finalization step. 322890dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) disk_cache::Entry* entry1; 322990dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) net::TestCompletionCallback cb1; 323090dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) disk_cache::Entry* entry2; 323190dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) net::TestCompletionCallback cb2; 323290dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) int rv1 = cache_->OpenEntry("key", &entry1, cb1.callback()); 323390dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) int rv2 = cache_->CreateEntry("key", &entry2, cb2.callback()); 323490dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) 323590dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) EXPECT_EQ(net::ERR_FAILED, cb1.GetResult(rv1)); 3236868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ASSERT_EQ(net::OK, cb2.GetResult(rv2)); 3237868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry2->Close(); 3238868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)} 3239868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3240868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)// Checks that reading two entries simultaneously does not discard a CRC check. 3241868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)// TODO(pasko): make it work with Simple Cache. 3242868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)TEST_F(DiskCacheEntryTest, DISABLED_SimpleCacheMultipleReadersCheckCRC) { 3243868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) SetSimpleCacheMode(); 3244868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) InitCache(); 3245868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3246868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) const char key[] = "key"; 3247868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3248868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) int size; 3249868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ASSERT_TRUE(SimpleCacheMakeBadChecksumEntry(key, &size)); 3250868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3251868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) scoped_refptr<net::IOBuffer> read_buffer1(new net::IOBuffer(size)); 3252868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) scoped_refptr<net::IOBuffer> read_buffer2(new net::IOBuffer(size)); 3253868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3254868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Advance the first reader a little. 3255868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) disk_cache::Entry* entry = NULL; 3256868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key, &entry)); 3257868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(1, ReadData(entry, 0, 0, read_buffer1.get(), 1)); 3258868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3259868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Make the second reader pass the point where the first one is, and close. 3260868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) disk_cache::Entry* entry2 = NULL; 3261868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(net::OK, OpenEntry(key, &entry2)); 3262868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(1, ReadData(entry2, 0, 0, read_buffer2.get(), 1)); 3263868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(1, ReadData(entry2, 0, 1, read_buffer2.get(), 1)); 3264868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry2->Close(); 3265868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3266868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Read the data till the end should produce an error. 3267868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_GT(0, ReadData(entry, 0, 1, read_buffer1.get(), size)); 3268868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->Close(); 3269868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) DisableIntegrityCheck(); 3270868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)} 3271868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3272868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)// Checking one more scenario of overlapped reading of a bad entry. 3273868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)// Differs from the |SimpleCacheMultipleReadersCheckCRC| only by the order of 3274868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)// last two reads. 3275868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheMultipleReadersCheckCRC2) { 3276868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) SetSimpleCacheMode(); 3277868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) InitCache(); 3278868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3279868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) const char key[] = "key"; 3280868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) int size; 3281868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ASSERT_TRUE(SimpleCacheMakeBadChecksumEntry(key, &size)); 3282868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3283868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) scoped_refptr<net::IOBuffer> read_buffer1(new net::IOBuffer(size)); 3284868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) scoped_refptr<net::IOBuffer> read_buffer2(new net::IOBuffer(size)); 3285868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3286868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Advance the first reader a little. 3287868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) disk_cache::Entry* entry = NULL; 3288868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key, &entry)); 3289bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ScopedEntryPtr entry_closer(entry); 3290868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(1, ReadData(entry, 0, 0, read_buffer1.get(), 1)); 3291868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3292868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Advance the 2nd reader by the same amount. 3293868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) disk_cache::Entry* entry2 = NULL; 3294868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(net::OK, OpenEntry(key, &entry2)); 3295bbcdd45c55eb7c4641ab97aef9889b0fc828e7d3Ben Murdoch ScopedEntryPtr entry2_closer(entry2); 3296868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(1, ReadData(entry2, 0, 0, read_buffer2.get(), 1)); 3297868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3298868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Continue reading 1st. 3299868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_GT(0, ReadData(entry, 0, 1, read_buffer1.get(), size)); 3300868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3301868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // This read should fail as well because we have previous read failures. 3302868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_GT(0, ReadData(entry2, 0, 1, read_buffer2.get(), 1)); 3303868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) DisableIntegrityCheck(); 3304868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)} 3305868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3306868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)// Test if we can sequentially read each subset of the data until all the data 3307868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)// is read, then the CRC is calculated correctly and the reads are successful. 3308868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheReadCombineCRC) { 3309868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Test sequence: 3310868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Create, Write, Read (first half of data), Read (second half of data), 3311868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Close. 3312868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) SetSimpleCacheMode(); 3313868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) InitCache(); 3314868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) disk_cache::Entry* null = NULL; 3315868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) const char key[] = "the first key"; 3316868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3317868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) const int kHalfSize = 200; 3318868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) const int kSize = 2 * kHalfSize; 3319868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize)); 3320868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) CacheTestFillBuffer(buffer1->data(), kSize, false); 3321868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) disk_cache::Entry* entry = NULL; 3322868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3323868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 3324868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_NE(null, entry); 3325868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 33267d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer1.get(), kSize, false)); 3327868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->Close(); 3328868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3329868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) disk_cache::Entry* entry2 = NULL; 3330868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key, &entry2)); 3331868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(entry, entry2); 3332868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3333868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Read the first half of the data. 3334868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) int offset = 0; 3335868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) int buf_len = kHalfSize; 3336868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer1_read1(new net::IOBuffer(buf_len)); 33377d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) EXPECT_EQ(buf_len, ReadData(entry2, 0, offset, buffer1_read1.get(), buf_len)); 3338868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(0, memcmp(buffer1->data(), buffer1_read1->data(), buf_len)); 3339868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3340868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Read the second half of the data. 3341868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) offset = buf_len; 3342868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buf_len = kHalfSize; 3343868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer1_read2(new net::IOBuffer(buf_len)); 33447d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) EXPECT_EQ(buf_len, ReadData(entry2, 0, offset, buffer1_read2.get(), buf_len)); 3345868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) char* buffer1_data = buffer1->data() + offset; 3346868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(0, memcmp(buffer1_data, buffer1_read2->data(), buf_len)); 3347868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3348868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Check that we are not leaking. 3349868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_NE(entry, null); 3350868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_TRUE( 3351868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef()); 3352868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->Close(); 3353868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry = NULL; 3354868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)} 3355868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3356868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)// Test if we can write the data not in sequence and read correctly. In 3357868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)// this case the CRC will not be present. 3358868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)TEST_F(DiskCacheEntryTest, SimpleCacheNonSequentialWrite) { 3359868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Test sequence: 3360868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Create, Write (second half of data), Write (first half of data), Read, 3361868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Close. 3362868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) SetSimpleCacheMode(); 3363868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) InitCache(); 3364868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) disk_cache::Entry* null = NULL; 3365868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) const char key[] = "the first key"; 3366868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3367868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) const int kHalfSize = 200; 3368868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) const int kSize = 2 * kHalfSize; 3369868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize)); 3370868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize)); 3371868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) CacheTestFillBuffer(buffer1->data(), kSize, false); 3372868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) char* buffer1_data = buffer1->data() + kHalfSize; 3373868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) memcpy(buffer2->data(), buffer1_data, kHalfSize); 3374868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) disk_cache::Entry* entry = NULL; 3375868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3376868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ASSERT_EQ(net::OK, CreateEntry(key, &entry)); 3377868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_NE(null, entry); 3378868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3379868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) int offset = kHalfSize; 3380868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) int buf_len = kHalfSize; 3381868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 33827d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) EXPECT_EQ(buf_len, 33837d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) WriteData(entry, 0, offset, buffer2.get(), buf_len, false)); 3384868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) offset = 0; 3385868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) buf_len = kHalfSize; 33867d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) EXPECT_EQ(buf_len, 33877d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) WriteData(entry, 0, offset, buffer1.get(), buf_len, false)); 3388868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->Close(); 3389868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3390868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) disk_cache::Entry* entry2 = NULL; 3391868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ASSERT_EQ(net::OK, OpenEntry(key, &entry2)); 3392868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(entry, entry2); 3393868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3394868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) scoped_refptr<net::IOBuffer> buffer1_read1(new net::IOBuffer(kSize)); 33957d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) EXPECT_EQ(kSize, ReadData(entry2, 0, 0, buffer1_read1.get(), kSize)); 3396868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_EQ(0, memcmp(buffer1->data(), buffer1_read1->data(), kSize)); 3397868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 3398868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Check that we are not leaking. 3399868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) ASSERT_NE(entry, null); 3400868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) EXPECT_TRUE( 3401868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef()); 3402868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry->Close(); 3403868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) entry = NULL; 340490dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)} 340590dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) 3406c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)#endif // defined(OS_POSIX) 3407