Disk Cache: Remove deprecated methods from the disk cache interface....

net/disk_cache/entry_unittest.cc

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();
 }