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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/disk_cache/backend_unittest.cc

Issue 3167020: Disk cache: Extend the internal buffering performed by each entry... (Closed) Base URL: svn://chrome-svn/chrome/trunk/src/
Patch Set: '' Created 10 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« net/disk_cache/backend_impl.cc ('K') | « net/disk_cache/backend_impl.cc ('k') | net/disk_cache/disk_cache_test_base.h » ('j') | net/disk_cache/disk_cache_test_base.cc » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/disk_cache/backend_unittest.cc
===================================================================
--- net/disk_cache/backend_unittest.cc (revision 55505)
+++ net/disk_cache/backend_unittest.cc (working copy)
@@ -224,7 +224,7 @@
// Now let's create a file with the cache.
disk_cache::Entry* entry;
ASSERT_EQ(net::OK, CreateEntry("key", &entry));
- ASSERT_EQ(0, entry->WriteData(0, 20000, buffer1, 0, NULL, false));
+ ASSERT_EQ(0, WriteData(entry, 0, 20000, buffer1, 0, false));
entry->Close();
// And verify that the first file is still there.
@@ -355,21 +355,21 @@
scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(cache_size);
memset(buffer->data(), 0, cache_size);
- EXPECT_EQ(cache_size / 10, entry->WriteData(0, 0, buffer, cache_size / 10,
- NULL, false)) << "normal file";
+ EXPECT_EQ(cache_size / 10, WriteData(entry, 0, 0, buffer, cache_size / 10,
+ false)) << "normal file";
- EXPECT_EQ(net::ERR_FAILED, entry->WriteData(1, 0, buffer, cache_size / 5,
- NULL, false)) << "file size above the limit";
+ EXPECT_EQ(net::ERR_FAILED, WriteData(entry, 1, 0, buffer, cache_size / 5,
+ false)) << "file size above the limit";
// By doubling the total size, we make this file cacheable.
SetMaxSize(cache_size * 2);
- EXPECT_EQ(cache_size / 5, entry->WriteData(1, 0, buffer, cache_size / 5,
- NULL, false));
+ EXPECT_EQ(cache_size / 5, WriteData(entry, 1, 0, buffer, cache_size / 5,
+ false));
// Let's fill up the cache!.
SetMaxSize(cache_size * 10);
- EXPECT_EQ(cache_size * 3 / 4, entry->WriteData(0, 0, buffer,
- cache_size * 3 / 4, NULL, false));
+ EXPECT_EQ(cache_size * 3 / 4, WriteData(entry, 0, 0, buffer,
+ cache_size * 3 / 4, false));
entry->Close();
FlushQueueForTest();
@@ -378,13 +378,13 @@
// The cache is 95% full.
ASSERT_EQ(net::OK, CreateEntry(second, &entry));
- EXPECT_EQ(cache_size / 10, entry->WriteData(0, 0, buffer, cache_size / 10,
- NULL, false));
+ EXPECT_EQ(cache_size / 10, WriteData(entry, 0, 0, buffer, cache_size / 10,
+ false));
disk_cache::Entry* entry2;
ASSERT_EQ(net::OK, CreateEntry("an extra key", &entry2));
- EXPECT_EQ(cache_size / 10, entry2->WriteData(0, 0, buffer, cache_size / 10,
- NULL, false));
+ EXPECT_EQ(cache_size / 10, WriteData(entry2, 0, 0, buffer, cache_size / 10,
+ false));
entry2->Close(); // This will trigger the cache trim.
EXPECT_NE(net::OK, OpenEntry(first, &entry2));
@@ -472,23 +472,23 @@
InitCache();
std::string key("Some key");
- disk_cache::Entry* entry1;
- ASSERT_EQ(net::OK, CreateEntry(key, &entry1));
+ disk_cache::Entry* entry;
+ ASSERT_EQ(net::OK, CreateEntry(key, &entry));
const int kSize = 50;
scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize);
memset(buffer1->data(), 0, kSize);
base::strlcpy(buffer1->data(), "And the data to save", kSize);
- EXPECT_EQ(kSize, entry1->WriteData(0, 0, buffer1, kSize, NULL, false));
- entry1->Close();
+ EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer1, kSize, false));
+ entry->Close();
SimulateCrash();
- ASSERT_EQ(net::OK, OpenEntry(key, &entry1));
+ ASSERT_EQ(net::OK, OpenEntry(key, &entry));
scoped_refptr<net::IOBuffer> buffer2 = new net::IOBuffer(kSize);
memset(buffer2->data(), 0, kSize);
- EXPECT_EQ(kSize, entry1->ReadData(0, 0, buffer2, kSize, NULL));
- entry1->Close();
+ EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer2, kSize));
+ entry->Close();
EXPECT_STREQ(buffer1->data(), buffer2->data());
}
@@ -510,17 +510,17 @@
InitCache();
std::string key("Some key");
- disk_cache::Entry* entry1;
- ASSERT_EQ(net::OK, CreateEntry(key, &entry1));
+ disk_cache::Entry* entry;
+ ASSERT_EQ(net::OK, CreateEntry(key, &entry));
const int kSize = 50;
- scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize);
- memset(buffer1->data(), 0, kSize);
- base::strlcpy(buffer1->data(), "And the data to save", kSize);
- EXPECT_EQ(kSize, entry1->WriteData(0, 0, buffer1, kSize, NULL, false));
+ scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kSize);
+ memset(buffer->data(), 0, kSize);
+ base::strlcpy(buffer->data(), "And the data to save", kSize);
+ EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));
SimulateCrash();
- EXPECT_NE(net::OK, OpenEntry(key, &entry1));
+ EXPECT_NE(net::OK, OpenEntry(key, &entry));
EXPECT_EQ(0, cache_->GetEntryCount());
}
@@ -548,21 +548,21 @@
InitCache();
std::string key("Some key");
- disk_cache::Entry* entry1;
- ASSERT_EQ(net::OK, CreateEntry(key, &entry1));
+ disk_cache::Entry* entry;
+ ASSERT_EQ(net::OK, CreateEntry(key, &entry));
const int kSize = 50;
- scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize);
- memset(buffer1->data(), 0, kSize);
- base::strlcpy(buffer1->data(), "And the data to save", kSize);
- EXPECT_EQ(kSize, entry1->WriteData(0, 0, buffer1, kSize, NULL, false));
- entry1->Close();
- ASSERT_EQ(net::OK, OpenEntry(key, &entry1));
- EXPECT_EQ(kSize, entry1->ReadData(0, 0, buffer1, kSize, NULL));
+ scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kSize);
+ memset(buffer->data(), 0, kSize);
+ base::strlcpy(buffer->data(), "And the data to save", kSize);
+ EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));
+ entry->Close();
+ ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+ EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer, kSize));
SimulateCrash();
- EXPECT_NE(net::OK, OpenEntry(key, &entry1));
+ EXPECT_NE(net::OK, OpenEntry(key, &entry));
EXPECT_EQ(0, cache_->GetEntryCount());
}
@@ -653,13 +653,13 @@
scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kSize);
memset(buffer->data(), 0, kSize);
- EXPECT_EQ(kSize, entry->WriteData(0, 0, buffer, kSize, NULL, false));
+ EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));
// Simulate a crash.
SimulateCrash();
ASSERT_EQ(net::OK, CreateEntry(second, &entry));
- EXPECT_EQ(kSize, entry->WriteData(0, 0, buffer, kSize, NULL, false));
+ EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));
EXPECT_EQ(2, cache_->GetEntryCount());
SetMaxSize(kSize);
@@ -703,7 +703,7 @@
for (int i = 0; i < 32; i++) {
std::string key(StringPrintf("some key %d", i));
ASSERT_EQ(net::OK, CreateEntry(key, &entry));
- EXPECT_EQ(kSize, entry->WriteData(0, 0, buffer, kSize, NULL, false));
+ EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));
entry->Close();
ASSERT_EQ(net::OK, OpenEntry(key, &entry));
// Note that we are not closing the entries.
@@ -713,7 +713,7 @@
SimulateCrash();
ASSERT_EQ(net::OK, CreateEntry("Something else", &entry));
- EXPECT_EQ(kSize, entry->WriteData(0, 0, buffer, kSize, NULL, false));
+ EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, false));
EXPECT_EQ(33, cache_->GetEntryCount());
SetMaxSize(kSize);
@@ -866,10 +866,10 @@
scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize);
memset(buffer1->data(), 0, kSize);
base::strlcpy(buffer1->data(), "And the data to save", kSize);
- EXPECT_EQ(kSize, entry1->WriteData(0, 0, buffer1, kSize, NULL, false));
+ EXPECT_EQ(kSize, WriteData(entry1, 0, 0, buffer1, kSize, false));
entry1->Close();
ASSERT_EQ(net::OK, OpenEntry(key, &entry1));
- EXPECT_EQ(kSize, entry1->ReadData(0, 0, buffer1, kSize, NULL));
+ EXPECT_EQ(kSize, ReadData(entry1, 0, 0, buffer1, kSize));
std::string key2("Another key");
ASSERT_EQ(net::OK, CreateEntry(key2, &entry2));
@@ -1499,8 +1499,8 @@
const int kBufSize = 20000;
scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kBufSize);
memset(buf->data(), 0, kBufSize);
- EXPECT_EQ(100, entry2->WriteData(0, 0, buf, 100, NULL, false));
- EXPECT_EQ(kBufSize, entry3->WriteData(0, 0, buf, kBufSize, NULL, false));
+ EXPECT_EQ(100, WriteData(entry2, 0, 0, buf, 100, false));
+ EXPECT_EQ(kBufSize, WriteData(entry3, 0, 0, buf, kBufSize, false));
// This line should disable the cache but not delete it.
EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry4));
@@ -1508,13 +1508,13 @@
EXPECT_NE(net::OK, CreateEntry("cache is disabled", &entry4));
- EXPECT_EQ(100, entry2->ReadData(0, 0, buf, 100, NULL));
- EXPECT_EQ(100, entry2->WriteData(0, 0, buf, 100, NULL, false));
- EXPECT_EQ(100, entry2->WriteData(1, 0, buf, 100, NULL, false));
+ EXPECT_EQ(100, ReadData(entry2, 0, 0, buf, 100));
+ EXPECT_EQ(100, WriteData(entry2, 0, 0, buf, 100, false));
+ EXPECT_EQ(100, WriteData(entry2, 1, 0, buf, 100, false));
- EXPECT_EQ(kBufSize, entry3->ReadData(0, 0, buf, kBufSize, NULL));
- EXPECT_EQ(kBufSize, entry3->WriteData(0, 0, buf, kBufSize, NULL, false));
- EXPECT_EQ(kBufSize, entry3->WriteData(1, 0, buf, kBufSize, NULL, false));
+ EXPECT_EQ(kBufSize, ReadData(entry3, 0, 0, buf, kBufSize));
+ EXPECT_EQ(kBufSize, WriteData(entry3, 0, 0, buf, kBufSize, false));
+ EXPECT_EQ(kBufSize, WriteData(entry3, 1, 0, buf, kBufSize, false));
std::string key = entry2->GetKey();
EXPECT_EQ(sizeof(key2) - 1, key.size());
@@ -1747,3 +1747,64 @@
CACHE_UMA(HOURS, "FillupTime", i, 28);
}
}
+
+// Make sure that we keep the total memory used by the internal buffers under
+// control.
+TEST_F(DiskCacheBackendTest, TotalBuffersSize1) {
+ SetDirectMode();
+ InitCache();
+ std::string key("the first key");
+ disk_cache::Entry* entry;
+ ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+
+ const int kSize = 200;
+ scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kSize);
+ CacheTestFillBuffer(buffer->data(), kSize, true);
+
+ for (int i = 0; i < 10; i++) {
+ SCOPED_TRACE(i);
+ // Allocate 2MB for this entry.
+ EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer, kSize, true));
+ EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer, kSize, true));
+ EXPECT_EQ(kSize, WriteData(entry, 0, 1024 * 1024, buffer, kSize, false));
+ EXPECT_EQ(kSize, WriteData(entry, 1, 1024 * 1024, buffer, kSize, false));
+
+ // Delete one of the buffers and truncate the other.
+ EXPECT_EQ(0, WriteData(entry, 0, 0, buffer, 0, true));
+ EXPECT_EQ(0, WriteData(entry, 1, 10, buffer, 0, true));
+
+ // Delete the second buffer, writing 10 bytes to disk.
+ entry->Close();
+ ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+ }
+
+ entry->Close();
+ EXPECT_EQ(0, cache_impl_->GetTotalBuffersSize());
+}
+
+// This test assumes at least 150MB of system memory.
+TEST_F(DiskCacheBackendTest, TotalBuffersSize2) {
+ SetDirectMode();
+ InitCache();
+
+ const int kOneMB = 1024 * 1024;
+ EXPECT_TRUE(cache_impl_->IsAllocAllowed(0, kOneMB));
+ EXPECT_EQ(kOneMB, cache_impl_->GetTotalBuffersSize());
+
+ EXPECT_TRUE(cache_impl_->IsAllocAllowed(0, kOneMB));
+ EXPECT_EQ(kOneMB * 2, cache_impl_->GetTotalBuffersSize());
+
+ EXPECT_TRUE(cache_impl_->IsAllocAllowed(0, kOneMB));
+ EXPECT_EQ(kOneMB * 3, cache_impl_->GetTotalBuffersSize());
+
+ cache_impl_->BufferDeleted(kOneMB);
+ EXPECT_EQ(kOneMB * 2, cache_impl_->GetTotalBuffersSize());
+
+ // Check the upper limit.
+ EXPECT_FALSE(cache_impl_->IsAllocAllowed(0, 30 * kOneMB));
+
+ for (int i = 0; i < 30; i++)
+ cache_impl_->IsAllocAllowed(0, kOneMB); // Ignore the result.
+
+ EXPECT_FALSE(cache_impl_->IsAllocAllowed(0, kOneMB));
+}
gavinp 2010/08/19 18:17:22 NIT: add a newline here
« net/disk_cache/backend_impl.cc ('K') | « net/disk_cache/backend_impl.cc ('k') | net/disk_cache/disk_cache_test_base.h » ('j') | net/disk_cache/disk_cache_test_base.cc » ('J')

Powered by Google App Engine
This is Rietveld 408576698