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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/disk_cache/backend_unittest.cc

Issue 592503002: Revert of Reland of "Remove void** from disk_cache interface." (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@1-webcacheimpl
Patch Set: Created 6 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « content/browser/service_worker/service_worker_cache.cc ('k') | net/disk_cache/blockfile/backend_impl.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/disk_cache/backend_unittest.cc
diff --git a/net/disk_cache/backend_unittest.cc b/net/disk_cache/backend_unittest.cc
index 572691c48b719545fb8bb51b4ad35c73124124ac..c3f2cfaf54c87962de6d08489335391214ddceec 100644
--- a/net/disk_cache/backend_unittest.cc
+++ b/net/disk_cache/backend_unittest.cc
@@ -81,7 +81,7 @@
bool CreateSetOfRandomEntries(std::set<std::string>* key_pool);
bool EnumerateAndMatchKeys(int max_to_open,
- TestIterator* iter,
+ void** iter,
std::set<std::string>* keys_to_match,
size_t* count);
@@ -256,14 +256,12 @@
// OpenNextEntry stops returning net::OK.
bool DiskCacheBackendTest::EnumerateAndMatchKeys(
int max_to_open,
- TestIterator* iter,
+ void** iter,
std::set<std::string>* keys_to_match,
size_t* count) {
disk_cache::Entry* entry;
- if (!iter)
- return false;
- while (iter->OpenNextEntry(&entry) == net::OK) {
+ while (OpenNextEntry(iter, &entry) == net::OK) {
if (!entry)
return false;
EXPECT_EQ(1U, keys_to_match->erase(entry->GetKey()));
@@ -1239,11 +1237,11 @@
Time final = Time::Now();
disk_cache::Entry* entry;
- scoped_ptr<TestIterator> iter = CreateIterator();
+ void* iter = NULL;
int count = 0;
Time last_modified[kNumEntries];
Time last_used[kNumEntries];
- while (iter->OpenNextEntry(&entry) == net::OK) {
+ while (OpenNextEntry(&iter, &entry) == net::OK) {
ASSERT_TRUE(NULL != entry);
if (count < kNumEntries) {
last_modified[count] = entry->GetLastModified();
@@ -1257,10 +1255,10 @@
};
EXPECT_EQ(kNumEntries, count);
- iter = CreateIterator();
+ iter = NULL;
count = 0;
// The previous enumeration should not have changed the timestamps.
- while (iter->OpenNextEntry(&entry) == net::OK) {
+ while (OpenNextEntry(&iter, &entry) == net::OK) {
ASSERT_TRUE(NULL != entry);
if (count < kNumEntries) {
EXPECT_TRUE(last_modified[count] == entry->GetLastModified());
@@ -1311,8 +1309,8 @@
// Make sure that the timestamp is not the same.
AddDelay();
ASSERT_EQ(net::OK, OpenEntry(second, &entry1));
- scoped_ptr<TestIterator> iter = CreateIterator();
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry2));
+ void* iter = NULL;
+ ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry2));
EXPECT_EQ(entry2->GetKey(), second);
// Two entries and the iterator pointing at "first".
@@ -1320,15 +1318,15 @@
entry2->Close();
// The iterator should still be valid, so we should not crash.
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry2));
+ ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry2));
EXPECT_EQ(entry2->GetKey(), first);
entry2->Close();
- iter = CreateIterator();
+ cache_->EndEnumeration(&iter);
// Modify the oldest entry and get the newest element.
ASSERT_EQ(net::OK, OpenEntry(first, &entry1));
EXPECT_EQ(0, WriteData(entry1, 0, 200, NULL, 0, false));
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry2));
+ ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry2));
if (type_ == net::APP_CACHE) {
// The list is not updated.
EXPECT_EQ(entry2->GetKey(), second);
@@ -1338,6 +1336,7 @@
entry1->Close();
entry2->Close();
+ cache_->EndEnumeration(&iter);
}
TEST_F(DiskCacheBackendTest, Enumerations2) {
@@ -1392,10 +1391,11 @@
EXPECT_EQ(kSize, ReadData(entry1, 0, 0, buffer1.get(), kSize));
entry1->Close();
- scoped_ptr<TestIterator> iter = CreateIterator();
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry2));
+ void* iter = NULL;
+ ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry2));
EXPECT_EQ(entry2->GetKey(), second);
entry2->Close();
+ cache_->EndEnumeration(&iter);
}
#if !defined(LEAK_SANITIZER)
@@ -1424,9 +1424,9 @@
SimulateCrash();
- scoped_ptr<TestIterator> iter = CreateIterator();
+ void* iter = NULL;
int count = 0;
- while (iter->OpenNextEntry(&entry) == net::OK) {
+ while (OpenNextEntry(&iter, &entry) == net::OK) {
ASSERT_TRUE(NULL != entry);
EXPECT_EQ(key2, entry->GetKey());
entry->Close();
@@ -1466,8 +1466,9 @@
EXPECT_EQ(kNumEntries, cache_->GetEntryCount());
disk_cache::Entry *entry1, *entry2;
- scoped_ptr<TestIterator> iter1 = CreateIterator(), iter2 = CreateIterator();
- ASSERT_EQ(net::OK, iter1->OpenNextEntry(&entry1));
+ void* iter1 = NULL;
+ void* iter2 = NULL;
+ ASSERT_EQ(net::OK, OpenNextEntry(&iter1, &entry1));
ASSERT_TRUE(NULL != entry1);
entry1->Close();
entry1 = NULL;
@@ -1476,17 +1477,17 @@
for (int i = 0; i < kNumEntries / 2; i++) {
if (entry1)
entry1->Close();
- ASSERT_EQ(net::OK, iter1->OpenNextEntry(&entry1));
+ ASSERT_EQ(net::OK, OpenNextEntry(&iter1, &entry1));
ASSERT_TRUE(NULL != entry1);
- ASSERT_EQ(net::OK, iter2->OpenNextEntry(&entry2));
+ ASSERT_EQ(net::OK, OpenNextEntry(&iter2, &entry2));
ASSERT_TRUE(NULL != entry2);
entry2->Close();
}
// Messing up with entry1 will modify entry2->next.
entry1->Doom();
- ASSERT_EQ(net::OK, iter2->OpenNextEntry(&entry2));
+ ASSERT_EQ(net::OK, OpenNextEntry(&iter2, &entry2));
ASSERT_TRUE(NULL != entry2);
// The link entry2->entry1 should be broken.
@@ -1495,9 +1496,12 @@
entry2->Close();
// And the second iterator should keep working.
- ASSERT_EQ(net::OK, iter2->OpenNextEntry(&entry2));
+ ASSERT_EQ(net::OK, OpenNextEntry(&iter2, &entry2));
ASSERT_TRUE(NULL != entry2);
entry2->Close();
+
+ cache_->EndEnumeration(&iter1);
+ cache_->EndEnumeration(&iter2);
}
TEST_F(DiskCacheBackendTest, FixEnumerators) {
@@ -2023,8 +2027,8 @@
InitCache();
disk_cache::Entry* entry;
- scoped_ptr<TestIterator> iter = CreateIterator();
- while (iter->OpenNextEntry(&entry) == net::OK) {
+ void* iter = NULL;
+ while (OpenNextEntry(&iter, &entry) == net::OK) {
entry->Close();
}
}
@@ -2168,8 +2172,8 @@
EXPECT_EQ(1, cache_->GetEntryCount());
// We should delete the cache. The list still has a corrupt node.
- scoped_ptr<TestIterator> iter = CreateIterator();
- EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
+ void* iter = NULL;
+ EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry));
FlushQueueForTest();
EXPECT_EQ(0, cache_->GetEntryCount());
}
@@ -2212,10 +2216,10 @@
EXPECT_EQ(1, cache_->GetEntryCount());
// We should not delete the cache.
- scoped_ptr<TestIterator> iter = CreateIterator();
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
- entry->Close();
- EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
+ void* iter = NULL;
+ ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry));
+ entry->Close();
+ EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry));
EXPECT_EQ(1, cache_->GetEntryCount());
}
@@ -2262,13 +2266,13 @@
} else {
// We should detect the problem through the list, but we should not delete
// the entry, just fail the iteration.
- scoped_ptr<TestIterator> iter = CreateIterator();
- EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
+ void* iter = NULL;
+ EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry));
// Now a full iteration will work, and return one entry.
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
+ ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry));
entry->Close();
- EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
+ EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry));
// This should detect what's left of the bad entry.
EXPECT_NE(net::OK, OpenEntry(second, &entry));
@@ -2339,13 +2343,13 @@
// Detection order: third -> second -> first.
// We should detect the problem through the list, but we should not delete
// the entry.
- scoped_ptr<TestIterator> iter = CreateIterator();
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
+ void* iter = NULL;
+ ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry));
entry->Close();
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
+ ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry));
EXPECT_EQ(first, entry->GetKey());
entry->Close();
- EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
+ EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry));
}
DisableIntegrityCheck();
}
@@ -2406,17 +2410,17 @@
// Detection order: third -> second.
// We should detect the problem through the list, but we should not delete
// the entry, just fail the iteration.
- scoped_ptr<TestIterator> iter = CreateIterator();
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
+ void* iter = NULL;
+ ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry));
entry->Close();
- EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
+ EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry));
// Now a full iteration will work, and return two entries.
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
+ ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry));
entry->Close();
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
+ ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry));
entry->Close();
- EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
+ EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry));
}
DisableIntegrityCheck();
}
@@ -2494,12 +2498,12 @@
// If the LRU is corrupt, we delete the cache.
void DiskCacheBackendTest::BackendInvalidRankings() {
disk_cache::Entry* entry;
- scoped_ptr<TestIterator> iter = CreateIterator();
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
+ void* iter = NULL;
+ ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry));
entry->Close();
EXPECT_EQ(2, cache_->GetEntryCount());
- EXPECT_NE(net::OK, iter->OpenNextEntry(&entry));
+ EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry));
FlushQueueForTest(); // Allow the restart to finish.
EXPECT_EQ(0, cache_->GetEntryCount());
}
@@ -2539,10 +2543,10 @@
// If the LRU is corrupt and we have open entries, we disable the cache.
void DiskCacheBackendTest::BackendDisable() {
disk_cache::Entry *entry1, *entry2;
- scoped_ptr<TestIterator> iter = CreateIterator();
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry1));
-
- EXPECT_NE(net::OK, iter->OpenNextEntry(&entry2));
+ void* iter = NULL;
+ ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry1));
+
+ EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry2));
EXPECT_EQ(0, cache_->GetEntryCount());
EXPECT_NE(net::OK, CreateEntry("Something new", &entry2));
@@ -2590,9 +2594,9 @@
EXPECT_EQ(8, cache_->GetEntryCount());
disk_cache::Entry* entry;
- scoped_ptr<TestIterator> iter = CreateIterator();
+ void* iter = NULL;
int count = 0;
- while (iter->OpenNextEntry(&entry) == net::OK) {
+ while (OpenNextEntry(&iter, &entry) == net::OK) {
ASSERT_TRUE(NULL != entry);
entry->Close();
count++;
@@ -2638,12 +2642,12 @@
// If the index size changes when we disable the cache, we should not crash.
void DiskCacheBackendTest::BackendDisable3() {
disk_cache::Entry *entry1, *entry2;
- scoped_ptr<TestIterator> iter = CreateIterator();
+ void* iter = NULL;
EXPECT_EQ(2, cache_->GetEntryCount());
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry1));
+ ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry1));
entry1->Close();
- EXPECT_NE(net::OK, iter->OpenNextEntry(&entry2));
+ EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry2));
FlushQueueForTest();
ASSERT_EQ(net::OK, CreateEntry("Something new", &entry2));
@@ -2672,8 +2676,8 @@
// If we disable the cache, already open entries should work as far as possible.
void DiskCacheBackendTest::BackendDisable4() {
disk_cache::Entry *entry1, *entry2, *entry3, *entry4;
- scoped_ptr<TestIterator> iter = CreateIterator();
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry1));
+ void* iter = NULL;
+ ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry1));
char key2[2000];
char key3[20000];
@@ -2691,7 +2695,7 @@
EXPECT_EQ(kBufSize, WriteData(entry3, 0, 0, buf.get(), kBufSize, false));
// This line should disable the cache but not delete it.
- EXPECT_NE(net::OK, iter->OpenNextEntry(&entry4));
+ EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry4));
EXPECT_EQ(0, cache_->GetEntryCount());
EXPECT_NE(net::OK, CreateEntry("cache is disabled", &entry4));
@@ -3372,29 +3376,29 @@
// Check that enumeration returns all entries.
std::set<std::string> keys_to_match(key_pool);
- scoped_ptr<TestIterator> iter = CreateIterator();
+ void* iter = NULL;
size_t count = 0;
- ASSERT_TRUE(EnumerateAndMatchKeys(-1, iter.get(), &keys_to_match, &count));
- iter.reset();
+ ASSERT_TRUE(EnumerateAndMatchKeys(-1, &iter, &keys_to_match, &count));
+ cache_->EndEnumeration(&iter);
EXPECT_EQ(key_pool.size(), count);
EXPECT_TRUE(keys_to_match.empty());
// Check that opening entries does not affect enumeration.
keys_to_match = key_pool;
- iter = CreateIterator();
+ iter = NULL;
count = 0;
disk_cache::Entry* entry_opened_before;
ASSERT_EQ(net::OK, OpenEntry(*(key_pool.begin()), &entry_opened_before));
ASSERT_TRUE(EnumerateAndMatchKeys(key_pool.size()/2,
- iter.get(),
+ &iter,
&keys_to_match,
&count));
disk_cache::Entry* entry_opened_middle;
ASSERT_EQ(net::OK,
OpenEntry(*(keys_to_match.begin()), &entry_opened_middle));
- ASSERT_TRUE(EnumerateAndMatchKeys(-1, iter.get(), &keys_to_match, &count));
- iter.reset();
+ ASSERT_TRUE(EnumerateAndMatchKeys(-1, &iter, &keys_to_match, &count));
+ cache_->EndEnumeration(&iter);
entry_opened_before->Close();
entry_opened_middle->Close();
@@ -3412,10 +3416,10 @@
// Check that enumeration returns all entries but the doomed one.
std::set<std::string> keys_to_match(key_pool);
- scoped_ptr<TestIterator> iter = CreateIterator();
+ void* iter = NULL;
size_t count = 0;
ASSERT_TRUE(EnumerateAndMatchKeys(key_pool.size()/2,
- iter.get(),
+ &iter,
&keys_to_match,
&count));
@@ -3423,8 +3427,8 @@
DoomEntry(key_to_delete);
keys_to_match.erase(key_to_delete);
key_pool.erase(key_to_delete);
- ASSERT_TRUE(EnumerateAndMatchKeys(-1, iter.get(), &keys_to_match, &count));
- iter.reset();
+ ASSERT_TRUE(EnumerateAndMatchKeys(-1, &iter, &keys_to_match, &count));
+ cache_->EndEnumeration(&iter);
EXPECT_EQ(key_pool.size(), count);
EXPECT_TRUE(keys_to_match.empty());
@@ -3460,10 +3464,10 @@
// Check that enumeration returns all entries but the corrupt one.
std::set<std::string> keys_to_match(key_pool);
- scoped_ptr<TestIterator> iter = CreateIterator();
+ void* iter = NULL;
size_t count = 0;
- ASSERT_TRUE(EnumerateAndMatchKeys(-1, iter.get(), &keys_to_match, &count));
- iter.reset();
+ ASSERT_TRUE(EnumerateAndMatchKeys(-1, &iter, &keys_to_match, &count));
+ cache_->EndEnumeration(&iter);
EXPECT_EQ(key_pool.size(), count);
EXPECT_TRUE(keys_to_match.empty());
@@ -3477,9 +3481,9 @@
std::set<std::string> key_pool;
ASSERT_TRUE(CreateSetOfRandomEntries(&key_pool));
- scoped_ptr<TestIterator> iter = CreateIterator();
+ void* iter = NULL;
disk_cache::Entry* entry = NULL;
- ASSERT_EQ(net::OK, iter->OpenNextEntry(&entry));
+ ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry));
EXPECT_TRUE(entry);
disk_cache::ScopedEntryPtr entry_closer(entry);
« no previous file with comments | « content/browser/service_worker/service_worker_cache.cc ('k') | net/disk_cache/blockfile/backend_impl.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698