Disk Cache: Implement GetAvailableRange for the regular disk 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"
@@ skipping 19 matching lines @@
   void GetKey();
   void GrowData();
   void TruncateData();
   void ZeroLengthIO();
   void ReuseEntry(int size);
   void InvalidData();
   void DoomEntry();
   void DoomedEntry();
   void BasicSparseIO(bool async);
   void HugeSparseIO(bool async);
+  void GetAvailableRange();
 };
 
 void DiskCacheEntryTest::InternalSyncIO() {
   disk_cache::Entry *entry1 = NULL;
   ASSERT_TRUE(cache_->CreateEntry("the first key", &entry1));
   ASSERT_TRUE(NULL != entry1);
 
   const int kSize1 = 10;
   scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1);
   CacheTestFillBuffer(buffer1->data(), kSize1, false);
@@ skipping 910 matching lines @@
   std::string key("the first key");
   disk_cache::Entry* entry;
   ASSERT_TRUE(cache_->CreateEntry(key, &entry));
 
   // Write 1.2 MB so that we cover multiple entries.
   const int kSize = 1200 * 1024;
   scoped_refptr<net::IOBuffer> buf_1 = new net::IOBuffer(kSize);
   scoped_refptr<net::IOBuffer> buf_2 = new net::IOBuffer(kSize);
   CacheTestFillBuffer(buf_1->data(), kSize, false);
 
-  // Write at offset 0x20F0000 (20 MB - 64 KB).
+  // Write at offset 0x20F0000 (33 MB - 64 KB).
   VerifySparseIO(entry, 0x20F0000, buf_1, kSize, async, buf_2);
   entry->Close();
 
   // Check it again.
   ASSERT_TRUE(cache_->OpenEntry(key, &entry));
   VerifyContentSparseIO(entry, 0x20F0000, buf_1->data(), kSize, async);
   entry->Close();
 }
 
 TEST_F(DiskCacheEntryTest, HugeSparseSyncIO) {
@@ skipping 10 matching lines @@
 TEST_F(DiskCacheEntryTest, HugeSparseAsyncIO) {
   InitCache();
   HugeSparseIO(true);
 }
 
 TEST_F(DiskCacheEntryTest, DISABLED_MemoryOnlyHugeSparseAsyncIO) {
   SetMemoryOnlyMode();
   InitCache();
   HugeSparseIO(true);
 }
+
+void DiskCacheEntryTest::GetAvailableRange() {
+  std::string key("the first key");
+  disk_cache::Entry* entry;
+  ASSERT_TRUE(cache_->CreateEntry(key, &entry));
+
+  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));
+  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));

[Nicolas Sylvain, 2009/06/23 02:49:07]

why is this returning kSize? is it not returning an result code?

[rvargas (doing something else), 2009/06/23 02:59:24]

GetAvailableRange returns the number of bytes stored from *start, or an error
code. It is OK to return a number that is lower than the real number of stored
bytes (to avoid opening extra child entries).

+  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));
+
+  start = 0;
+  EXPECT_EQ(0x2000, entry->GetAvailableRange(0x20F2000, kSize, &start));
+  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));
+  EXPECT_EQ(0x20F0000, start);
+
+  entry->Close();
+}
+
+TEST_F(DiskCacheEntryTest, GetAvailableRange) {
+  InitCache();
+  GetAvailableRange();
+}
+
+TEST_F(DiskCacheEntryTest, DISABLED_MemoryOnlyGetAvailableRange) {
+  SetMemoryOnlyMode();
+  InitCache();
+  GetAvailableRange();
+}