Http cache: Add a test to make sure that the cache...

net/disk_cache/entry_unittest.cc

 // Copyright (c) 2006-2009 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"
+#include "net/base/test_completion_callback.h"
 #include "net/disk_cache/disk_cache_test_base.h"
 #include "net/disk_cache/disk_cache_test_util.h"
 #include "net/disk_cache/entry_impl.h"
 #include "net/disk_cache/mem_entry_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 
 extern volatile int g_cache_tests_received;
 extern volatile bool g_cache_tests_error;
@@ skipping 852 matching lines @@
     EXPECT_EQ(disk_cache::MemEntryImpl::kParentEntry, mem_entry->type());
     mem_entry->Close();
   }
   EXPECT_EQ(1, count);
 }
 
 // Writes |buf_1| to offset and reads it back as |buf_2|.
 void VerifySparseIO(disk_cache::Entry* entry, int64 offset,
                     net::IOBuffer* buf_1, int size, bool async,
                     net::IOBuffer* buf_2) {
-  SimpleCallbackTest callback;
-  SimpleCallbackTest* cb = async ? &callback : NULL;
+  TestCompletionCallback callback;
+  TestCompletionCallback* cb = async ? &callback : NULL;
 
   memset(buf_2->data(), 0, size);
   int ret = entry->ReadSparseData(offset, buf_2, size, cb);
   ret = callback.GetResult(ret);
   EXPECT_EQ(0, ret);
 
   ret = entry->WriteSparseData(offset, buf_1, size, cb);
   ret = callback.GetResult(ret);
   EXPECT_EQ(size, ret);
 
   ret = entry->ReadSparseData(offset, buf_2, size, cb);
   ret = callback.GetResult(ret);
   EXPECT_EQ(size, ret);
 
   EXPECT_EQ(0, memcmp(buf_1->data(), buf_2->data(), size));
 }
 
 // Reads |size| bytes from |entry| at |offset| and verifies that they are the
 // same as the content of the provided |buffer|.
 void VerifyContentSparseIO(disk_cache::Entry* entry, int64 offset, char* buffer,
                            int size, bool async) {
-  SimpleCallbackTest callback;
-  SimpleCallbackTest* cb = async ? &callback : NULL;
+  TestCompletionCallback callback;
+  TestCompletionCallback* cb = async ? &callback : NULL;
 
   scoped_refptr<net::IOBuffer> buf_1 = new net::IOBuffer(size);
   memset(buf_1->data(), 0, size);
   int ret = entry->ReadSparseData(offset, buf_1, size, cb);
   ret = callback.GetResult(ret);
   EXPECT_EQ(size, ret);
 
   EXPECT_EQ(0, memcmp(buf_1->data(), buffer, size));
 }
 
@@ skipping 429 matching lines @@
 TEST_F(DiskCacheEntryTest, CancelSparseIO) {
   InitCache();
   std::string key("the first key");
   disk_cache::Entry* entry;
   ASSERT_TRUE(cache_->CreateEntry(key, &entry));
 
   const int kSize = 40 * 1024;
   scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize);
   CacheTestFillBuffer(buf->data(), kSize, false);
 
-  SimpleCallbackTest cb1, cb2, cb3, cb4;
+  TestCompletionCallback cb1, cb2, cb3, cb4;
   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;
     }
@@ skipping 23 matching lines @@
   // 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));
   EXPECT_EQ(net::OK, entry->ReadyForSparseIO(&cb2));
   entry->Close();
 }