1 files changed, 172 insertions, 0 deletions
diff --git a/net/disk_cache/entry_unittest.cc b/net/disk_cache/entry_unittest.cc
index 99c31a6..b8c9e66 100644
--- a/net/disk_cache/entry_unittest.cc
+++ b/net/disk_cache/entry_unittest.cc
@@ -64,6 +64,8 @@ class DiskCacheEntryTest : public DiskCacheTestWithCache {
   void DoomSparseEntry();
   void PartialSparseEntry();
   bool SimpleCacheMakeBadChecksumEntry(const std::string& key, int* data_size);
+  bool SimpleCacheThirdStreamFileExists(const char* key);
+  void SyncDoomEntry(const char* key);
 };
 
 // This part of the test runs on the background thread.
@@ -3606,4 +3608,174 @@ TEST_F(DiskCacheEntryTest, SimpleCacheCRCRewrite) {
   }
 }
 
+bool DiskCacheEntryTest::SimpleCacheThirdStreamFileExists(const char* key) {
+  int third_stream_file_index =
+      disk_cache::simple_util::GetFileIndexFromStreamIndex(2);
+  base::FilePath third_stream_file_path = cache_path_.AppendASCII(
+      disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(
+          key, third_stream_file_index));
+  return PathExists(third_stream_file_path);
+}
+
+void DiskCacheEntryTest::SyncDoomEntry(const char* key) {
+  net::TestCompletionCallback callback;
+  cache_->DoomEntry(key, callback.callback());
+  callback.WaitForResult();
+}
+
+// Check that a newly-created entry with no third-stream writes omits the
+// third stream file.
+TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream1) {
+  SetSimpleCacheMode();
+  InitCache();
+
+  const int kHalfSize = 8;
+  const int kSize = kHalfSize * 2;
+  const char key[] = "key";
+  scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
+  scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
+  CacheTestFillBuffer(buffer1->data(), kHalfSize, false);
+
+  disk_cache::Entry* entry;
+
+  // Create entry and close without writing: third stream file should be
+  // omitted, since the stream is empty.
+  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  entry->Close();
+  EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
+
+  SyncDoomEntry(key);
+  EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
+}
+
+// Check that a newly-created entry with only a single zero-offset, zero-length
+// write omits the third stream file.
+TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream2) {
+  SetSimpleCacheMode();
+  InitCache();
+
+  const int kHalfSize = 8;
+  const int kSize = kHalfSize * 2;
+  const char key[] = "key";
+  scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
+  scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
+  CacheTestFillBuffer(buffer1->data(), kHalfSize, false);
+
+  disk_cache::Entry* entry;
+  int buf_len;
+
+  // Create entry, write empty buffer to third stream, and close: third stream
+  // should still be omitted, since the entry ignores writes that don't modify
+  // data or change the length.
+  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  buf_len = WriteData(entry, 2, 0, buffer1, 0, true);
+  ASSERT_EQ(0, buf_len);
+  entry->Close();
+  EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
+
+  SyncDoomEntry(key);
+  EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
+}
+
+// Check that we can read back data written to the third stream.
+TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream3) {
+  SetSimpleCacheMode();
+  InitCache();
+
+  const int kHalfSize = 8;
+  const int kSize = kHalfSize * 2;
+  const char key[] = "key";
+  scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
+  scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
+  CacheTestFillBuffer(buffer1->data(), kHalfSize, false);
+
+  disk_cache::Entry* entry;
+  int buf_len;
+
+  // Create entry, write data to third stream, and close: third stream should
+  // not be omitted, since it contains data.  Re-open entry and ensure there
+  // are that many bytes in the third stream.
+  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  buf_len = WriteData(entry, 2, 0, buffer1, kHalfSize, true);
+  ASSERT_EQ(kHalfSize, buf_len);
+  entry->Close();
+  EXPECT_TRUE(SimpleCacheThirdStreamFileExists(key));
+
+  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  buf_len = ReadData(entry, 2, 0, buffer2, kSize);
+  ASSERT_EQ(buf_len, kHalfSize);
+  // TODO: Compare data?
+  entry->Close();
+  EXPECT_TRUE(SimpleCacheThirdStreamFileExists(key));
+
+  SyncDoomEntry(key);
+  EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
+}
+
+// Check that we remove the third stream file upon opening an entry and finding
+// the third stream empty.  (This is the upgrade path for entries written
+// before the third stream was optional.)
+TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream4) {
+  SetSimpleCacheMode();
+  InitCache();
+
+  const int kHalfSize = 8;
+  const int kSize = kHalfSize * 2;
+  const char key[] = "key";
+  scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
+  scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
+  CacheTestFillBuffer(buffer1->data(), kHalfSize, false);
+
+  disk_cache::Entry* entry;
+  int buf_len;
+
+  // Create entry, write data to third stream, truncate third stream back to
+  // empty, and close: third stream will not initially be omitted, since entry
+  // creates the file when the first significant write comes in, and only
+  // removes it on open if it is empty.  Reopen, ensure that the file is
+  // deleted, and that there's no data in the third stream.
+  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  buf_len = WriteData(entry, 2, 0, buffer1, kHalfSize, true);
+  ASSERT_EQ(kHalfSize, buf_len);
+  buf_len = WriteData(entry, 2, 0, buffer1, 0, true);
+  ASSERT_EQ(0, buf_len);
+  entry->Close();
+  EXPECT_TRUE(SimpleCacheThirdStreamFileExists(key));
+
+  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
+  buf_len = ReadData(entry, 2, 0, buffer2, kSize);
+  ASSERT_EQ(0, buf_len);
+  entry->Close();
+  EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
+
+  SyncDoomEntry(key);
+  EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
+}
+
+// Check that we don't accidentally create the third stream file once the entry
+// has been doomed.
+TEST_F(DiskCacheEntryTest, SimpleCacheOmittedThirdStream5) {
+  SetSimpleCacheMode();
+  InitCache();
+
+  const int kHalfSize = 8;
+  const int kSize = kHalfSize * 2;
+  const char key[] = "key";
+  scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
+  scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
+  CacheTestFillBuffer(buffer1->data(), kHalfSize, false);
+
+  disk_cache::Entry* entry;
+
+  // Create entry, doom entry, write data to third stream, and close: third
+  // stream should not exist.  (Note: We don't care if the write fails, just
+  // that it doesn't cause the file to be created on disk.)
+  ASSERT_EQ(net::OK, CreateEntry(key, &entry));
+  entry->Doom();
+  WriteData(entry, 2, 0, buffer1, kHalfSize, true);
+  entry->Close();
+  EXPECT_FALSE(SimpleCacheThirdStreamFileExists(key));
+}
+
 #endif  // defined(OS_POSIX)