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

net/disk_cache/entry_unittest.cc

 // Copyright (c) 2006-2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/basictypes.h"
 #include "base/platform_thread.h"
 #include "base/timer.h"
 #include "base/string_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 1008 matching lines @@
   const int kSize = 16 * 1024;
   scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize);
   CacheTestFillBuffer(buf->data(), kSize, false);
 
   // Write at offset 0x20F0000 (33 MB - 64 KB), and 0x20F4400 (33 MB - 47 KB).
   EXPECT_EQ(kSize, entry->WriteSparseData(0x20F0000, buf, kSize, NULL));
   EXPECT_EQ(kSize, entry->WriteSparseData(0x20F4400, buf, kSize, NULL));
 
   // 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();
 }
 
 TEST_F(DiskCacheEntryTest, GetAvailableRange) {
   InitCache();
   GetAvailableRange();
 }
 
@@ skipping 95 matching lines @@
 
   // Writes in the middle of an entry.
   EXPECT_EQ(1024, entry->WriteSparseData(0, buf, 1024, NULL));
   EXPECT_EQ(1024, entry->WriteSparseData(5120, buf, 1024, NULL));
   EXPECT_EQ(1024, entry->WriteSparseData(10000, buf, 1024, NULL));
 
   // Writes in the middle of an entry and spans 2 child entries.
   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();
 }
 
 void DiskCacheEntryTest::DoomSparseEntry() {
   std::string key1("the first key");
   std::string key2("the second key");
   disk_cache::Entry *entry1, *entry2;
   ASSERT_EQ(net::OK, CreateEntry(key1, &entry1));
@@ skipping 84 matching lines @@
 
   EXPECT_EQ(500, entry->ReadSparseData(kSize, buf2, kSize, NULL));
   EXPECT_EQ(0, memcmp(buf2->data(), buf1->data() + kSize - 500, 500));
   EXPECT_EQ(0, entry->ReadSparseData(0, buf2, kSize, NULL));
 
   // This read should not change anything.
   EXPECT_EQ(96, entry->ReadSparseData(24000, buf2, kSize, NULL));
   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));
   EXPECT_EQ(0, memcmp(buf2->data() + 500, buf1->data(), kSize - 500));
 
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, PartialSparseEntry) {
   InitCache();
@@ skipping 60 matching lines @@
 TEST_F(DiskCacheEntryTest, CancelSparseIO) {
   InitCache();
   std::string key("the first key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   const int kSize = 40 * 1024;
   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.
   for (int ret = 0; ret != net::ERR_IO_PENDING; offset += kSize * 4) {
     ret = entry->WriteSparseData(offset, buf, kSize, &cb1);
     if (++tries > maxtries) {
        LOG(ERROR) << "Data writes never come back PENDING; skipping test";
        entry->Close();
        return;
     }
   }
 
   // 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.
   entry->CancelSparseIO();
   EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadyForSparseIO(&cb2));
   EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadyForSparseIO(&cb3));
   entry->CancelSparseIO();  // Should be a no op at this point.
   EXPECT_EQ(net::ERR_IO_PENDING, entry->ReadyForSparseIO(&cb4));
 
   offset = 0;
-  EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED,
-            entry->GetAvailableRange(offset, kSize, &offset));
+  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->ReadSparseData(offset, buf, kSize, NULL));
   EXPECT_EQ(net::ERR_CACHE_OPERATION_NOT_SUPPORTED,
             entry->WriteSparseData(offset, buf, kSize, NULL));
 
   // Now see if we receive all notifications.
   EXPECT_EQ(kSize, cb1.GetResult(net::ERR_IO_PENDING));
   EXPECT_EQ(net::OK, cb2.GetResult(net::ERR_IO_PENDING));
   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();
 }