Index: net/disk_cache/entry_unittest.cc |
=================================================================== |
--- net/disk_cache/entry_unittest.cc (revision 49603) |
+++ net/disk_cache/entry_unittest.cc (working copy) |
@@ -1026,28 +1026,37 @@ |
// We stop at the first empty block. |
int64 start; |
- EXPECT_EQ(kSize, entry->GetAvailableRange(0x20F0000, kSize * 2, &start)); |
+ TestCompletionCallback cb; |
+ int rv = entry->GetAvailableRange(0x20F0000, kSize * 2, &start, &cb); |
+ EXPECT_EQ(kSize, cb.GetResult(rv)); |
EXPECT_EQ(0x20F0000, start); |
start = 0; |
- EXPECT_EQ(0, entry->GetAvailableRange(0, kSize, &start)); |
- EXPECT_EQ(0, entry->GetAvailableRange(0x20F0000 - kSize, kSize, &start)); |
- EXPECT_EQ(kSize, entry->GetAvailableRange(0, 0x2100000, &start)); |
+ rv = entry->GetAvailableRange(0, kSize, &start, &cb); |
+ EXPECT_EQ(0, cb.GetResult(rv)); |
+ rv = entry->GetAvailableRange(0x20F0000 - kSize, kSize, &start, &cb); |
+ EXPECT_EQ(0, cb.GetResult(rv)); |
+ rv = entry->GetAvailableRange(0, 0x2100000, &start, &cb); |
+ EXPECT_EQ(kSize, cb.GetResult(rv)); |
EXPECT_EQ(0x20F0000, start); |
// We should be able to Read based on the results of GetAvailableRange. |
start = -1; |
- EXPECT_EQ(0, entry->GetAvailableRange(0x2100000, kSize, &start)); |
- EXPECT_EQ(0, entry->ReadSparseData(start, buf, kSize, NULL)); |
+ rv = entry->GetAvailableRange(0x2100000, kSize, &start, &cb); |
+ EXPECT_EQ(0, cb.GetResult(rv)); |
+ rv = entry->ReadSparseData(start, buf, kSize, &cb); |
+ EXPECT_EQ(0, cb.GetResult(rv)); |
start = 0; |
- EXPECT_EQ(0x2000, entry->GetAvailableRange(0x20F2000, kSize, &start)); |
+ rv = entry->GetAvailableRange(0x20F2000, kSize, &start, &cb); |
+ EXPECT_EQ(0x2000, cb.GetResult(rv)); |
EXPECT_EQ(0x20F2000, start); |
EXPECT_EQ(0x2000, entry->ReadSparseData(start, buf, kSize, NULL)); |
// Make sure that we respect the |len| argument. |
start = 0; |
- EXPECT_EQ(1, entry->GetAvailableRange(0x20F0001 - kSize, kSize, &start)); |
+ rv = entry->GetAvailableRange(0x20F0001 - kSize, kSize, &start, &cb); |
+ EXPECT_EQ(1, cb.GetResult(rv)); |
EXPECT_EQ(0x20F0000, start); |
entry->Close(); |
@@ -1163,31 +1172,38 @@ |
EXPECT_EQ(8192, entry->WriteSparseData(50000, buf, 8192, NULL)); |
int64 start; |
+ TestCompletionCallback cb; |
// Test that we stop at a discontinuous child at the second block. |
- EXPECT_EQ(1024, entry->GetAvailableRange(0, 10000, &start)); |
+ int rv = entry->GetAvailableRange(0, 10000, &start, &cb); |
+ EXPECT_EQ(1024, cb.GetResult(rv)); |
EXPECT_EQ(0, start); |
// Test that number of bytes is reported correctly when we start from the |
// middle of a filled region. |
- EXPECT_EQ(512, entry->GetAvailableRange(512, 10000, &start)); |
+ rv = entry->GetAvailableRange(512, 10000, &start, &cb); |
+ EXPECT_EQ(512, cb.GetResult(rv)); |
EXPECT_EQ(512, start); |
// Test that we found bytes in the child of next block. |
- EXPECT_EQ(1024, entry->GetAvailableRange(1024, 10000, &start)); |
+ rv = entry->GetAvailableRange(1024, 10000, &start, &cb); |
+ EXPECT_EQ(1024, cb.GetResult(rv)); |
EXPECT_EQ(5120, start); |
// Test that the desired length is respected. It starts within a filled |
// region. |
- EXPECT_EQ(512, entry->GetAvailableRange(5500, 512, &start)); |
+ rv = entry->GetAvailableRange(5500, 512, &start, &cb); |
+ EXPECT_EQ(512, cb.GetResult(rv)); |
EXPECT_EQ(5500, start); |
// Test that the desired length is respected. It starts before a filled |
// region. |
- EXPECT_EQ(500, entry->GetAvailableRange(5000, 620, &start)); |
+ rv = entry->GetAvailableRange(5000, 620, &start, &cb); |
+ EXPECT_EQ(500, cb.GetResult(rv)); |
EXPECT_EQ(5120, start); |
// Test that multiple blocks are scanned. |
- EXPECT_EQ(8192, entry->GetAvailableRange(40000, 20000, &start)); |
+ rv = entry->GetAvailableRange(40000, 20000, &start, &cb); |
+ EXPECT_EQ(8192, cb.GetResult(rv)); |
EXPECT_EQ(50000, start); |
entry->Close(); |
@@ -1292,37 +1308,48 @@ |
EXPECT_EQ(500, entry->ReadSparseData(kSize, buf2, kSize, NULL)); |
EXPECT_EQ(0, entry->ReadSparseData(499, buf2, kSize, NULL)); |
+ int rv; |
int64 start; |
+ TestCompletionCallback cb; |
if (memory_only_) { |
- EXPECT_EQ(100, entry->GetAvailableRange(0, 600, &start)); |
+ rv = entry->GetAvailableRange(0, 600, &start, &cb); |
+ EXPECT_EQ(100, cb.GetResult(rv)); |
EXPECT_EQ(500, start); |
} else { |
- EXPECT_EQ(1024, entry->GetAvailableRange(0, 2048, &start)); |
+ rv = entry->GetAvailableRange(0, 2048, &start, &cb); |
+ EXPECT_EQ(1024, cb.GetResult(rv)); |
EXPECT_EQ(1024, start); |
} |
- EXPECT_EQ(500, entry->GetAvailableRange(kSize, kSize, &start)); |
+ rv = entry->GetAvailableRange(kSize, kSize, &start, &cb); |
+ EXPECT_EQ(500, cb.GetResult(rv)); |
EXPECT_EQ(kSize, start); |
- EXPECT_EQ(3616, entry->GetAvailableRange(20 * 1024, 10000, &start)); |
+ rv = entry->GetAvailableRange(20 * 1024, 10000, &start, &cb); |
+ EXPECT_EQ(3616, cb.GetResult(rv)); |
EXPECT_EQ(20 * 1024, start); |
// 1. Query before a filled 1KB block. |
// 2. Query within a filled 1KB block. |
// 3. Query beyond a filled 1KB block. |
if (memory_only_) { |
- EXPECT_EQ(3496, entry->GetAvailableRange(19400, kSize, &start)); |
+ rv = entry->GetAvailableRange(19400, kSize, &start, &cb); |
+ EXPECT_EQ(3496, cb.GetResult(rv)); |
EXPECT_EQ(20000, start); |
} else { |
- EXPECT_EQ(3016, entry->GetAvailableRange(19400, kSize, &start)); |
+ rv = entry->GetAvailableRange(19400, kSize, &start, &cb); |
+ EXPECT_EQ(3016, cb.GetResult(rv)); |
EXPECT_EQ(20480, start); |
} |
- EXPECT_EQ(1523, entry->GetAvailableRange(3073, kSize, &start)); |
+ rv = entry->GetAvailableRange(3073, kSize, &start, &cb); |
+ EXPECT_EQ(1523, cb.GetResult(rv)); |
EXPECT_EQ(3073, start); |
- EXPECT_EQ(0, entry->GetAvailableRange(4600, kSize, &start)); |
+ rv = entry->GetAvailableRange(4600, kSize, &start, &cb); |
+ EXPECT_EQ(0, cb.GetResult(rv)); |
EXPECT_EQ(4600, start); |
// Now make another write and verify that there is no hole in between. |
EXPECT_EQ(kSize, entry->WriteSparseData(500 + kSize, buf1, kSize, NULL)); |
- EXPECT_EQ(7 * 1024 + 500, entry->GetAvailableRange(1024, 10000, &start)); |
+ rv = entry->GetAvailableRange(1024, 10000, &start, &cb); |
+ EXPECT_EQ(7 * 1024 + 500, cb.GetResult(rv)); |
EXPECT_EQ(1024, start); |
EXPECT_EQ(kSize, entry->ReadSparseData(kSize, buf2, kSize, NULL)); |
EXPECT_EQ(0, memcmp(buf2->data(), buf1->data() + kSize - 500, 500)); |
@@ -1403,7 +1430,7 @@ |
scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize); |
CacheTestFillBuffer(buf->data(), kSize, false); |
- TestCompletionCallback cb1, cb2, cb3, cb4; |
+ TestCompletionCallback cb1, cb2, cb3, cb4, cb5; |
int64 offset = 0; |
int tries = 0; |
const int maxtries = 100; // Avoid hang on infinitely fast disks. |
@@ -1418,8 +1445,8 @@ |
// Cannot use the entry at this point. |
offset = 0; |
- EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED, |
- entry->GetAvailableRange(offset, kSize, &offset)); |
+ int rv = entry->GetAvailableRange(offset, kSize, &offset, &cb5); |
+ EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED, cb5.GetResult(rv)); |
EXPECT_EQ(net::OK, entry->ReadyForSparseIO(&cb2)); |
// We cancel the pending operation, and register multiple notifications. |
@@ -1430,9 +1457,9 @@ |
EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadyForSparseIO(&cb4)); |
offset = 0; |
+ rv = entry->GetAvailableRange(offset, kSize, &offset, &cb5); |
+ EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED, cb5.GetResult(rv)); |
EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED, |
- entry->GetAvailableRange(offset, kSize, &offset)); |
- EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED, |
entry->ReadSparseData(offset, buf, kSize, NULL)); |
EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED, |
entry->WriteSparseData(offset, buf, kSize, NULL)); |
@@ -1443,7 +1470,8 @@ |
EXPECT_EQ(net::OK, cb3.GetResult(net::ERR_IO_PENDING)); |
EXPECT_EQ(net::OK, cb4.GetResult(net::ERR_IO_PENDING)); |
- EXPECT_EQ(kSize, entry->GetAvailableRange(offset, kSize, &offset)); |
+ rv = entry->GetAvailableRange(offset, kSize, &offset, &cb5); |
+ EXPECT_EQ(kSize, cb5.GetResult(rv)); |
EXPECT_EQ(net::OK, entry->ReadyForSparseIO(&cb2)); |
entry->Close(); |
} |