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"
 #include "base/threading/platform_thread.h"
 #include "base/timer/timer.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/disk_cache/backend_impl.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 "net/disk_cache/simple/simple_entry_format.h"
 #include "net/disk_cache/simple/simple_entry_impl.h"
+#include "net/disk_cache/simple/simple_synchronous_entry.h"
 #include "net/disk_cache/simple/simple_test_util.h"
 #include "net/disk_cache/simple/simple_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 using disk_cache::ScopedEntryPtr;
 
 // Tests that can run with different types of caches.
 class DiskCacheEntryTest : public DiskCacheTestWithCache {
  public:
@@ skipping 21 matching lines @@
   void DoomNormalEntry();
   void DoomEntryNextToOpenEntry();
   void DoomedEntry();
   void BasicSparseIO();
   void HugeSparseIO();
   void GetAvailableRange();
   void CouldBeSparse();
   void UpdateSparseEntry();
   void DoomSparseEntry();
   void PartialSparseEntry();
-  bool SimpleCacheMakeBadChecksumEntry(const char* key, int* data_size);
+  bool SimpleCacheMakeBadChecksumEntry(const std::string& key, int* data_size);
 };
 
 // This part of the test runs on the background thread.
 void DiskCacheEntryTest::InternalSyncIOBackground(disk_cache::Entry* entry) {
   const int kSize1 = 10;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
   CacheTestFillBuffer(buffer1->data(), kSize1, false);
   EXPECT_EQ(
       0,
       entry->ReadData(0, 0, buffer1.get(), kSize1, net::CompletionCallback()));
@@ skipping 2331 matching lines @@
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheDoomedEntry) {
   SetSimpleCacheMode();
   InitCache();
   DoomedEntry();
 }
 
 // Creates an entry with corrupted last byte in stream 0.
 // Requires SimpleCacheMode.
-bool DiskCacheEntryTest::SimpleCacheMakeBadChecksumEntry(const char* key,
+bool DiskCacheEntryTest::SimpleCacheMakeBadChecksumEntry(const std::string& key,
                                                          int* data_size) {
   disk_cache::Entry* entry = NULL;
 
   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));
+      disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(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);
+      sizeof(disk_cache::SimpleFileHeader) + key.size() + kDataSize - 2;
   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 18 matching lines @@
   // Force the entry to flush to disk, so subsequent platform file operations
   // succed.
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
   entry->Close();
   entry = NULL;
 
   // Truncate the file such that the length isn't sufficient to have an EOF
   // record.
   int kTruncationBytes = -implicit_cast<int>(sizeof(disk_cache::SimpleFileEOF));
   const base::FilePath entry_path = cache_path_.AppendASCII(
-      disk_cache::simple_util::GetFilenameFromKeyAndIndex(key, 0));
+      disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, 0));
   const int64 invalid_size =
       disk_cache::simple_util::GetFileSizeFromKeyAndDataSize(key,
                                                              kTruncationBytes);
   EXPECT_TRUE(TruncatePath(entry_path, invalid_size));
   EXPECT_EQ(net::ERR_FAILED, OpenEntry(key, &entry));
   DisableIntegrityCheck();
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheNonOptimisticOperationsBasic) {
   // Test sequence:
   // Create, Write, Read, Close.
   SetCacheType(net::APP_CACHE);  // APP_CACHE doesn't use optimistic operations.
   SetSimpleCacheMode();
   InitCache();
   disk_cache::Entry* const null_entry = NULL;
 
   disk_cache::Entry* entry = NULL;
   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);
   EXPECT_EQ(
       write_buffer->size(),
-      WriteData(entry, 0, 0, write_buffer.get(), write_buffer->size(), false));
+      WriteData(entry, 1, 0, write_buffer.get(), write_buffer->size(), false));
 
   scoped_refptr<net::IOBufferWithSize> read_buffer(
       new net::IOBufferWithSize(kBufferSize));
-  EXPECT_EQ(
-      read_buffer->size(),
-      ReadData(entry, 0, 0, read_buffer.get(), read_buffer->size()));
+  EXPECT_EQ(read_buffer->size(),
+            ReadData(entry, 1, 0, read_buffer.get(), read_buffer->size()));
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheNonOptimisticOperationsDontBlock) {
   // Test sequence:
   // Create, Write, Close.
   SetCacheType(net::APP_CACHE);  // APP_CACHE doesn't use optimistic operations.
   SetSimpleCacheMode();
   InitCache();
   disk_cache::Entry* const null_entry = NULL;
 
   MessageLoopHelper helper;
   CallbackTest create_callback(&helper, false);
 
   int expected_callback_runs = 0;
   const int kBufferSize = 10;
   scoped_refptr<net::IOBufferWithSize> write_buffer(
       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 31 matching lines @@
   ASSERT_EQ(net::OK,
             cache_->CreateEntry(key, &entry,
                                 base::Bind(&CallbackTest::Run,
                                            base::Unretained(&callback1))));
   EXPECT_NE(null, entry);
   ScopedEntryPtr entry_closer(entry);
 
   // This write may or may not be optimistic (it depends if the previous
   // optimistic create already finished by the time we call the write here).
   int ret = entry->WriteData(
-      0,
+      1,
       0,
       buffer1.get(),
       kSize1,
       base::Bind(&CallbackTest::Run, base::Unretained(&callback2)),
       false);
   EXPECT_TRUE(kSize1 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   // This Read must not be optimistic, since we don't support that yet.
   EXPECT_EQ(net::ERR_IO_PENDING,
             entry->ReadData(
-                0,
+                1,
                 0,
                 buffer1_read.get(),
                 kSize1,
                 base::Bind(&CallbackTest::Run, base::Unretained(&callback3))));
   expected++;
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
   EXPECT_EQ(0, memcmp(buffer1->data(), buffer1_read->data(), kSize1));
 
   // At this point after waiting, the pending operations queue on the entry
   // should be empty, so the next Write operation must run as optimistic.
   EXPECT_EQ(kSize2,
             entry->WriteData(
-                0,
+                1,
                 0,
                 buffer2.get(),
                 kSize2,
                 base::Bind(&CallbackTest::Run, base::Unretained(&callback4)),
                 false));
 
   // Lets do another read so we block until both the write and the read
   // operation finishes and we can then test for HasOneRef() below.
   EXPECT_EQ(net::ERR_IO_PENDING,
             entry->ReadData(
-                0,
+                1,
                 0,
                 buffer2_read.get(),
                 kSize2,
                 base::Bind(&CallbackTest::Run, base::Unretained(&callback5))));
   expected++;
 
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
   EXPECT_EQ(0, memcmp(buffer2->data(), buffer2_read->data(), kSize2));
 
   // Check that we are not leaking.
@@ skipping 85 matching lines @@
 
   ASSERT_EQ(net::OK,
             cache_->CreateEntry(key, &entry, net::CompletionCallback()));
   EXPECT_NE(null, entry);
   entry->Close();
 
   // Lets do a Write so we block until both the Close and the Write
   // operation finishes. Write must fail since we are writing in a closed entry.
   EXPECT_EQ(
       net::ERR_IO_PENDING,
-      entry->WriteData(0, 0, buffer1.get(), kSize1, cb.callback(), false));
+      entry->WriteData(1, 0, buffer1.get(), kSize1, cb.callback(), false));
   EXPECT_EQ(net::ERR_FAILED, cb.GetResult(net::ERR_IO_PENDING));
 
   // Finish running the pending tasks so that we fully complete the close
   // operation and destroy the entry object.
   base::MessageLoop::current()->RunUntilIdle();
 
   // At this point the |entry| must have been destroyed, and called
   // RemoveSelfFromBackend().
   disk_cache::Entry* entry2 = NULL;
   ASSERT_EQ(net::ERR_IO_PENDING,
             cache_->OpenEntry(key, &entry2, cb.callback()));
   ASSERT_EQ(net::OK, cb.GetResult(net::ERR_IO_PENDING));
   EXPECT_NE(null, entry2);
 
   disk_cache::Entry* entry3 = NULL;
   ASSERT_EQ(net::ERR_IO_PENDING,
             cache_->OpenEntry(key, &entry3, cb.callback()));
   ASSERT_EQ(net::OK, cb.GetResult(net::ERR_IO_PENDING));
   EXPECT_NE(null, entry3);
   EXPECT_EQ(entry2, entry3);
   entry3->Close();
 
   // The previous Close doesn't actually closes the entry since we opened it
   // twice, so the next Write operation must succeed and it must be able to
   // perform it optimistically, since there is no operation running on this
   // entry.
   EXPECT_EQ(kSize1,
             entry2->WriteData(
-                0, 0, buffer1.get(), kSize1, net::CompletionCallback(), false));
+                1, 0, buffer1.get(), kSize1, net::CompletionCallback(), false));
 
   // Lets do another read so we block until both the write and the read
   // operation finishes and we can then test for HasOneRef() below.
   EXPECT_EQ(net::ERR_IO_PENDING,
-            entry2->ReadData(0, 0, buffer1.get(), kSize1, cb.callback()));
+            entry2->ReadData(1, 0, buffer1.get(), kSize1, cb.callback()));
   EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));
 
   // Check that we are not leaking.
   EXPECT_TRUE(
       static_cast<disk_cache::SimpleEntryImpl*>(entry2)->HasOneRef());
   entry2->Close();
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic5) {
   // Test sequence:
@@ skipping 10 matching lines @@
   disk_cache::Entry* entry = NULL;
 
   ASSERT_EQ(net::OK,
             cache_->CreateEntry(key, &entry, net::CompletionCallback()));
   EXPECT_NE(null, entry);
   ScopedEntryPtr entry_closer(entry);
   entry->Doom();
 
   EXPECT_EQ(
       net::ERR_IO_PENDING,
-      entry->WriteData(0, 0, buffer1.get(), kSize1, cb.callback(), false));
+      entry->WriteData(1, 0, buffer1.get(), kSize1, cb.callback(), false));
   EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));
 
   EXPECT_EQ(net::ERR_IO_PENDING,
-            entry->ReadData(0, 0, buffer1.get(), kSize1, cb.callback()));
+            entry->ReadData(1, 0, buffer1.get(), kSize1, cb.callback()));
   EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));
 
   // Check that we are not leaking.
   EXPECT_TRUE(
       static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheOptimistic6) {
   // Test sequence:
   // Create, Write, Doom, Doom, Read, Doom, Close.
   SetSimpleCacheMode();
   InitCache();
   disk_cache::Entry* null = NULL;
   const char key[] = "the first key";
 
   net::TestCompletionCallback cb;
   const int kSize1 = 10;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize1));
   scoped_refptr<net::IOBuffer> buffer1_read(new net::IOBuffer(kSize1));
   CacheTestFillBuffer(buffer1->data(), kSize1, false);
   disk_cache::Entry* entry = NULL;
 
   ASSERT_EQ(net::OK,
             cache_->CreateEntry(key, &entry, net::CompletionCallback()));
   EXPECT_NE(null, entry);
   ScopedEntryPtr entry_closer(entry);
 
   EXPECT_EQ(
       net::ERR_IO_PENDING,
-      entry->WriteData(0, 0, buffer1.get(), kSize1, cb.callback(), false));
+      entry->WriteData(1, 0, buffer1.get(), kSize1, cb.callback(), false));
   EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));
 
   entry->Doom();
   entry->Doom();
 
   // This Read must not be optimistic, since we don't support that yet.
   EXPECT_EQ(net::ERR_IO_PENDING,
-            entry->ReadData(0, 0, buffer1_read.get(), kSize1, cb.callback()));
+            entry->ReadData(1, 0, buffer1_read.get(), kSize1, cb.callback()));
   EXPECT_EQ(kSize1, cb.GetResult(net::ERR_IO_PENDING));
   EXPECT_EQ(0, memcmp(buffer1->data(), buffer1_read->data(), kSize1));
 
   entry->Doom();
 }
 
 // Confirm that IO buffers are not referenced by the Simple Cache after a write
 // completes.
 TEST_F(DiskCacheEntryTest, SimpleCacheOptimisticWriteReleases) {
   SetSimpleCacheMode();
@@ skipping 10 matching lines @@
 
   const int kWriteSize = 512;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kWriteSize));
   EXPECT_TRUE(buffer1->HasOneRef());
   CacheTestFillBuffer(buffer1->data(), kWriteSize, false);
 
   // An optimistic write happens only when there is an empty queue of pending
   // operations. To ensure the queue is empty, we issue a write and wait until
   // it completes.
   EXPECT_EQ(kWriteSize,
-            WriteData(entry, 0, 0, buffer1.get(), kWriteSize, false));
+            WriteData(entry, 1, 0, buffer1.get(), kWriteSize, false));
   EXPECT_TRUE(buffer1->HasOneRef());
 
   // Finally, we should perform an optimistic write and confirm that all
   // references to the IO buffer have been released.
   EXPECT_EQ(
       kWriteSize,
       entry->WriteData(
           1, 0, buffer1.get(), kWriteSize, net::CompletionCallback(), false));
   EXPECT_TRUE(buffer1->HasOneRef());
 }
@@ skipping 24 matching lines @@
       entry->WriteData(0, 0, buffer1.get(), kSize1, cb.callback(), false));
 
   entry->Close();
 
   // Finish running the pending tasks so that we fully complete the close
   // operation and destroy the entry object.
   base::MessageLoop::current()->RunUntilIdle();
 
   for (int i = 0; i < disk_cache::kSimpleEntryFileCount; ++i) {
     base::FilePath entry_file_path = cache_path_.AppendASCII(
-        disk_cache::simple_util::GetFilenameFromKeyAndIndex(key, i));
+        disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, i));
     base::PlatformFileInfo info;
     EXPECT_FALSE(file_util::GetFileInfo(entry_file_path, &info));
   }
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheDoomCreateRace) {
   // This test runs as APP_CACHE to make operations more synchronous. Test
   // sequence:
   // Create, Doom, Create.
   SetCacheType(net::APP_CACHE);
@@ skipping 121 matching lines @@
   SetSimpleCacheMode();
   SetMaxSize(kMaxSize);
   InitCache();
 
   std::string key1("the first key");
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry(key1, &entry));
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kWriteSize));
   CacheTestFillBuffer(buffer->data(), kWriteSize, false);
   EXPECT_EQ(kWriteSize,
-            WriteData(entry, 0, 0, buffer.get(), kWriteSize, false));
+            WriteData(entry, 1, 0, buffer.get(), kWriteSize, false));
   entry->Close();
   AddDelay();
 
   std::string key2("the key prefix");
   for (int i = 0; i < kNumExtraEntries; i++) {
     ASSERT_EQ(net::OK, CreateEntry(key2 + base::StringPrintf("%d", i), &entry));
     ScopedEntryPtr entry_closer(entry);
     EXPECT_EQ(kWriteSize,
-              WriteData(entry, 0, 0, buffer.get(), kWriteSize, false));
+              WriteData(entry, 1, 0, buffer.get(), kWriteSize, false));
   }
 
   // TODO(pasko): Find a way to wait for the eviction task(s) to finish by using
   // the internal knowledge about |SimpleBackendImpl|.
   ASSERT_NE(net::OK, OpenEntry(key1, &entry))
       << "Should have evicted the old entry";
   for (int i = 0; i < 2; i++) {
     int entry_no = kNumExtraEntries - i - 1;
     // Generally there is no guarantee that at this point the backround eviction
     // is finished. We are testing the positive case, i.e. when the eviction
@@ skipping 15 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 19 matching lines @@
 
   const int kBufferSize = 1024;
   scoped_refptr<net::IOBuffer> write_buffer(new net::IOBuffer(kBufferSize));
   CacheTestFillBuffer(write_buffer->data(), kBufferSize, false);
 
   MessageLoopHelper helper;
   int expected = 0;
 
   CallbackTest write_callback(&helper, false);
   EXPECT_EQ(net::ERR_IO_PENDING,
-            entry->WriteData(0,
+            entry->WriteData(1,
                              0,
                              write_buffer.get(),
                              kBufferSize,
                              base::Bind(&CallbackTest::Run,
                                         base::Unretained(&write_callback)),
                              true));
   ++expected;
 
   scoped_refptr<net::IOBuffer> read_buffer(new net::IOBuffer(kBufferSize));
   CallbackTest read_callback(&helper, false);
   EXPECT_EQ(net::ERR_IO_PENDING,
-            entry->ReadData(0,
+            entry->ReadData(1,
                             0,
                             read_buffer.get(),
                             kBufferSize,
                             base::Bind(&CallbackTest::Run,
                                        base::Unretained(&read_callback))));
   ++expected;
 
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
   EXPECT_EQ(kBufferSize, write_callback.last_result());
   EXPECT_EQ(kBufferSize, read_callback.last_result());
@@ skipping 63 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();
   InitCache();
   disk_cache::Entry* null = NULL;
   const char key[] = "the first key";
 
   const int kHalfSize = 200;
   const int kSize = 2 * kHalfSize;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer1->data(), kSize, false);
   disk_cache::Entry* entry = NULL;
 
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
   EXPECT_NE(null, entry);
 
-  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer1.get(), kSize, false));
+  EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer1.get(), kSize, false));
   entry->Close();
 
   disk_cache::Entry* entry2 = NULL;
   ASSERT_EQ(net::OK, OpenEntry(key, &entry2));
   EXPECT_EQ(entry, entry2);
 
   // Read the first half of the data.
   int offset = 0;
   int buf_len = kHalfSize;
   scoped_refptr<net::IOBuffer> buffer1_read1(new net::IOBuffer(buf_len));
-  EXPECT_EQ(buf_len, ReadData(entry2, 0, offset, buffer1_read1.get(), buf_len));
+  EXPECT_EQ(buf_len, ReadData(entry2, 1, offset, buffer1_read1.get(), buf_len));
   EXPECT_EQ(0, memcmp(buffer1->data(), buffer1_read1->data(), buf_len));
 
   // Read the second half of the data.
   offset = buf_len;
   buf_len = kHalfSize;
   scoped_refptr<net::IOBuffer> buffer1_read2(new net::IOBuffer(buf_len));
-  EXPECT_EQ(buf_len, ReadData(entry2, 0, offset, buffer1_read2.get(), buf_len));
+  EXPECT_EQ(buf_len, ReadData(entry2, 1, offset, buffer1_read2.get(), buf_len));
   char* buffer1_data = buffer1->data() + offset;
   EXPECT_EQ(0, memcmp(buffer1_data, buffer1_read2->data(), buf_len));
 
   // Check that we are not leaking.
   EXPECT_NE(entry, null);
   EXPECT_TRUE(
       static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
   entry->Close();
   entry = NULL;
 }
@@ skipping 41 matching lines @@
   EXPECT_EQ(0, memcmp(buffer1->data(), buffer1_read1->data(), kSize));
 
   // Check that we are not leaking.
   ASSERT_NE(entry, null);
   EXPECT_TRUE(
       static_cast<disk_cache::SimpleEntryImpl*>(entry)->HasOneRef());
   entry->Close();
   entry = NULL;
 }
 
+// Test that changing stream1 size does not affect stream0 (stream0 and stream1
+// are stored in the same file in Simple Cache).
+TEST_F(DiskCacheEntryTest, SimpleCacheStream1SizeChanges) {
+  SetSimpleCacheMode();
+  InitCache();
+  disk_cache::Entry* entry = NULL;
+  const char key[] = "the key";
+  const int kSize = 100;
+  scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
+  scoped_refptr<net::IOBuffer> buffer_read(new net::IOBuffer(kSize));
+  CacheTestFillBuffer(buffer->data(), kSize, false);
+
+  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  EXPECT_TRUE(entry);
+
+  // Write something in stream0.

[pasko, 2013/09/18 16:53:56]

s/in/to/

[clamy, 2013/09/18 17:20:46]

Done.

+  EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
+  EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer_read.get(), kSize));
+  EXPECT_EQ(0, memcmp(buffer->data(), buffer_read->data(), kSize));
+  entry->Close();
+
+  // Extend stream1.
+  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  int stream1_size = 100;
+  EXPECT_EQ(0, WriteData(entry, 1, stream1_size, buffer.get(), 0, false));
+  EXPECT_EQ(stream1_size, entry->GetDataSize(1));
+  entry->Close();
+
+  // Check that stream0 data has not been modified and that the EOF record for
+  // stream 0 contains a crc.
+  // The entry needs to be reopened before checking the crc: Open will perform
+  // the synchronization with the previous Close. This ensures the EOF records
+  // have been written to disk before we attempt to read them independently.
+  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  base::FilePath entry_file0_path = cache_path_.AppendASCII(
+      disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, 0));
+  int flags = base::PLATFORM_FILE_READ | base::PLATFORM_FILE_OPEN;
+  base::PlatformFile entry_file0 =
+      base::CreatePlatformFile(entry_file0_path, flags, NULL, NULL);
+  ASSERT_TRUE(entry_file0 != base::kInvalidPlatformFileValue);
+
+  int data_size[disk_cache::kSimpleEntryStreamCount] = {kSize, stream1_size, 0};
+  disk_cache::SimpleEntryStat entry_stat(
+      base::Time::Now(), base::Time::Now(), data_size);
+  int eof_offset = entry_stat.GetEOFOffsetInFile(key, 0);
+  disk_cache::SimpleFileEOF eof_record;
+  ASSERT_EQ(static_cast<int>(sizeof(eof_record)), base::ReadPlatformFile(
+      entry_file0,
+      eof_offset,
+      reinterpret_cast<char*>(&eof_record),
+      sizeof(eof_record)));
+  EXPECT_EQ(disk_cache::kSimpleFinalMagicNumber, eof_record.final_magic_number);
+  EXPECT_TRUE((eof_record.flags & disk_cache::SimpleFileEOF::FLAG_HAS_CRC32) ==
+              disk_cache::SimpleFileEOF::FLAG_HAS_CRC32);
+
+  buffer_read = new net::IOBuffer(kSize);
+  EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer_read.get(), kSize));
+  EXPECT_EQ(0, memcmp(buffer->data(), buffer_read->data(), kSize));
+
+  // Reduce stream1.

[pasko, 2013/09/18 16:53:56]

Shrink?

[clamy, 2013/09/18 17:20:46]

Done.

+  stream1_size = 50;
+  EXPECT_EQ(0, WriteData(entry, 1, stream1_size, buffer.get(), 0, true));
+  EXPECT_EQ(stream1_size, entry->GetDataSize(1));
+  entry->Close();
+
+  // Check that stream0 data has not been modified.
+  buffer_read = new net::IOBuffer(kSize);
+  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer_read.get(), kSize));
+  EXPECT_EQ(0, memcmp(buffer->data(), buffer_read->data(), kSize));
+  entry->Close();
+  entry = NULL;
+}
+
 #endif  // defined(OS_POSIX)