SimpleCache: merge the first and second stream in one file

net/disk_cache/entry_unittest.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 2409 matching lines @@
   if (CreateEntry(key, &entry) != net::OK || !entry) {
     LOG(ERROR) << "Could not create entry";
     return false;
   }
 
   const char data[] = "this is very good data";
   const int kDataSize = arraysize(data);
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kDataSize));
   base::strlcpy(buffer->data(), data, kDataSize);
 
-  EXPECT_EQ(kDataSize, WriteData(entry, 0, 0, buffer.get(), kDataSize, false));
+  EXPECT_EQ(kDataSize, WriteData(entry, 1, 0, buffer.get(), kDataSize, false));
   entry->Close();
   entry = NULL;
 
   // Corrupt the last byte of the data.
   base::FilePath entry_file0_path = cache_path_.AppendASCII(
       disk_cache::simple_util::GetFilenameFromKeyAndIndex(key, 0));
   int flags = base::PLATFORM_FILE_WRITE | base::PLATFORM_FILE_OPEN;
   base::PlatformFile entry_file0 =
       base::CreatePlatformFile(entry_file0_path, flags, NULL, NULL);
   if (entry_file0 == base::kInvalidPlatformFileValue)
     return false;
-  int64 file_offset =
-      disk_cache::simple_util::GetFileOffsetFromKeyAndDataOffset(
-          key, kDataSize - 2);
+  int64 file_offset = disk_cache::simple_util::GetFileOffsetFromDataOffset(
+      key, kDataSize - 2, 1, 0);
   EXPECT_EQ(1, base::WritePlatformFile(entry_file0, file_offset, "X", 1));
   if (!base::ClosePlatformFile(entry_file0))
     return false;
   *data_size = kDataSize;
   return true;
 }
 
 // Tests that the simple cache can detect entries that have bad data.
 TEST_F(DiskCacheEntryTest, SimpleCacheBadChecksum) {
   SetSimpleCacheMode();
   InitCache();
 
   const char key[] = "the first key";
   int size_unused;
   ASSERT_TRUE(SimpleCacheMakeBadChecksumEntry(key, &size_unused));
 
   disk_cache::Entry* entry = NULL;
 
   // Open the entry.
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
   ScopedEntryPtr entry_closer(entry);
 
   const int kReadBufferSize = 200;
-  EXPECT_GE(kReadBufferSize, entry->GetDataSize(0));
+  EXPECT_GE(kReadBufferSize, entry->GetDataSize(1));
   scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kReadBufferSize));
   EXPECT_EQ(net::ERR_CACHE_CHECKSUM_MISMATCH,
-            ReadData(entry, 0, 0, read_buffer.get(), kReadBufferSize));
+            ReadData(entry, 1, 0, read_buffer.get(), kReadBufferSize));
 }
 
 // Tests that an entry that has had an IO error occur can still be Doomed().
 TEST_F(DiskCacheEntryTest, SimpleCacheErrorThenDoom) {
   SetSimpleCacheMode();
   InitCache();
 
   const char key[] = "the first key";
   int size_unused;
   ASSERT_TRUE(SimpleCacheMakeBadChecksumEntry(key, &size_unused));
 
   disk_cache::Entry* entry = NULL;
 
   // Open the entry, forcing an IO error.
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
   ScopedEntryPtr entry_closer(entry);
 
   const int kReadBufferSize = 200;
-  EXPECT_GE(kReadBufferSize, entry->GetDataSize(0));
+  EXPECT_GE(kReadBufferSize, entry->GetDataSize(1));
   scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kReadBufferSize));
   EXPECT_EQ(net::ERR_CACHE_CHECKSUM_MISMATCH,
-            ReadData(entry, 0, 0, read_buffer.get(), kReadBufferSize));
+            ReadData(entry, 1, 0, read_buffer.get(), kReadBufferSize));
 
   entry->Doom();  // Should not crash.
 }
 
 bool TruncatePath(const base::FilePath& file_path, int64 length)  {
   const int flags = base::PLATFORM_FILE_WRITE | base::PLATFORM_FILE_OPEN;
   base::PlatformFile file =
       base::CreatePlatformFile(file_path, flags, NULL, NULL);
   if (base::kInvalidPlatformFileValue == file)
     return false;
@@ skipping 79 matching lines @@
       new net::IOBufferWithSize(kBufferSize));
 
   disk_cache::Entry* entry = NULL;
   EXPECT_EQ(net::OK, CreateEntry("my key", &entry));
   ASSERT_NE(null_entry, entry);
   ScopedEntryPtr entry_closer(entry);
 
   CacheTestFillBuffer(write_buffer->data(), write_buffer->size(), false);
   CallbackTest write_callback(&helper, false);
   int ret = entry->WriteData(
-      0,
+      1,
       0,
       write_buffer.get(),
       write_buffer->size(),
       base::Bind(&CallbackTest::Run, base::Unretained(&write_callback)),
       false);
   ASSERT_EQ(net::ERR_IO_PENDING, ret);
   helper.WaitUntilCacheIoFinished(++expected_callback_runs);
 }
 
 TEST_F(DiskCacheEntryTest,
@@ skipping 12 matching lines @@
   EXPECT_EQ(net::OK, CreateEntry("my key", &entry));
   ASSERT_NE(null_entry, entry);
   ScopedEntryPtr entry_closer(entry);
 
   const int kBufferSize = 10;
   scoped_refptr<net::IOBufferWithSize> write_buffer(
       new net::IOBufferWithSize(kBufferSize));
   CacheTestFillBuffer(write_buffer->data(), write_buffer->size(), false);
   CallbackTest write_callback(&helper, false);
   int ret = entry->WriteData(
-      0,
+      1,
       0,
       write_buffer.get(),
       write_buffer->size(),
       base::Bind(&CallbackTest::Run, base::Unretained(&write_callback)),
       false);
   EXPECT_EQ(net::ERR_IO_PENDING, ret);
   int expected_callback_runs = 1;
 
   scoped_refptr<net::IOBufferWithSize> read_buffer(
       new net::IOBufferWithSize(kBufferSize));
   CallbackTest read_callback(&helper, false);
   ret = entry->ReadData(
-      0,
+      1,
       0,
       read_buffer.get(),
       read_buffer->size(),
       base::Bind(&CallbackTest::Run, base::Unretained(&read_callback)));
   EXPECT_EQ(net::ERR_IO_PENDING, ret);
   ++expected_callback_runs;
 
   helper.WaitUntilCacheIoFinished(expected_callback_runs);
   ASSERT_EQ(read_buffer->size(), write_buffer->size());
   EXPECT_EQ(
@@ skipping 465 matching lines @@
   const char key[] = "the first key";
 
   const int kBufferSize = 1024;
   scoped_refptr<net::IOBuffer> write_buffer(new net::IOBuffer(kBufferSize));
   CacheTestFillBuffer(write_buffer->data(), kBufferSize, false);
 
   disk_cache::Entry* entry = NULL;
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 
   EXPECT_EQ(kBufferSize,
-            WriteData(entry, 0, 0, write_buffer.get(), kBufferSize, false));
+            WriteData(entry, 1, 0, write_buffer.get(), kBufferSize, false));
   entry->Close();
   entry = NULL;
 
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
   ScopedEntryPtr entry_closer(entry);
 
   MessageLoopHelper helper;
   int expected = 0;
 
   // Make a short read.
   const int kReadBufferSize = 512;
   scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kReadBufferSize));
   CallbackTest read_callback(&helper, false);
   EXPECT_EQ(net::ERR_IO_PENDING,
-            entry->ReadData(0,
+            entry->ReadData(1,
                             0,
                             read_buffer.get(),
                             kReadBufferSize,
                             base::Bind(&CallbackTest::Run,
                                        base::Unretained(&read_callback))));
   ++expected;
 
   // Truncate the entry to the length of that read.
   scoped_refptr<net::IOBuffer>
       truncate_buffer(new net::IOBuffer(kReadBufferSize));
   CacheTestFillBuffer(truncate_buffer->data(), kReadBufferSize, false);
   CallbackTest truncate_callback(&helper, false);
   EXPECT_EQ(net::ERR_IO_PENDING,
-            entry->WriteData(0,
+            entry->WriteData(1,
                              0,
                              truncate_buffer.get(),
                              kReadBufferSize,
                              base::Bind(&CallbackTest::Run,
                                         base::Unretained(&truncate_callback)),
                              true));
   ++expected;
 
   // Wait for both the read and truncation to finish, and confirm that both
   // succeeded.
@@ skipping 115 matching lines @@
   int size;
   ASSERT_TRUE(SimpleCacheMakeBadChecksumEntry(key, &size));
 
   scoped_refptr<net::IOBuffer> read_buffer1(new net::IOBuffer(size));
   scoped_refptr<net::IOBuffer> read_buffer2(new net::IOBuffer(size));
 
   // Advance the first reader a little.
   disk_cache::Entry* entry = NULL;
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
   ScopedEntryPtr entry_closer(entry);
-  EXPECT_EQ(1, ReadData(entry, 0, 0, read_buffer1.get(), 1));
+  EXPECT_EQ(1, ReadData(entry, 1, 0, read_buffer1.get(), 1));
 
   // Advance the 2nd reader by the same amount.
   disk_cache::Entry* entry2 = NULL;
   EXPECT_EQ(net::OK, OpenEntry(key, &entry2));
   ScopedEntryPtr entry2_closer(entry2);
-  EXPECT_EQ(1, ReadData(entry2, 0, 0, read_buffer2.get(), 1));
+  EXPECT_EQ(1, ReadData(entry2, 1, 0, read_buffer2.get(), 1));
 
   // Continue reading 1st.
-  EXPECT_GT(0, ReadData(entry, 0, 1, read_buffer1.get(), size));
+  EXPECT_GT(0, ReadData(entry, 1, 1, read_buffer1.get(), size));
 
   // This read should fail as well because we have previous read failures.
-  EXPECT_GT(0, ReadData(entry2, 0, 1, read_buffer2.get(), 1));
+  EXPECT_GT(0, ReadData(entry2, 1, 1, read_buffer2.get(), 1));
   DisableIntegrityCheck();
 }
 
 // Test if we can sequentially read each subset of the data until all the data
 // is read, then the CRC is calculated correctly and the reads are successful.
 TEST_F(DiskCacheEntryTest, SimpleCacheReadCombineCRC) {
   // Test sequence:
   // Create, Write, Read (first half of data), Read (second half of data),
   // Close.
   SetSimpleCacheMode();
@@ skipping 84 matching lines @@
 
   // Check that we are not leaking.
   ASSERT_NE(entry, null);
   EXPECT_TRUE(
       static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
   entry->Close();
   entry = NULL;
 }
 
 #endif  // defined(OS_POSIX)