Support optimistic Create and Write operations on the SimpleCache.

net/disk_cache/backend_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/file_util.h"
 #include "base/port.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
@@ skipping 2838 matching lines @@
   InitCache();
 
   const char* key = "the first key";
   disk_cache::Entry* entry = NULL;
 
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
   ASSERT_TRUE(entry != NULL);
   entry->Close();
   entry = NULL;
 
+  // To make sure the file creation completed we need to call open again so that

[gavinp, 2013/05/01 13:11:22]

Good catch on this.

I think it should be moved out into simple_test_util.h, so that when it's used,
it's clear that we're using a hack to force syncing to filesystem files.

[felipeg, 2013/05/02 09:49:27]

Done.

[gavinp, 2013/05/02 12:47:39]

Not done, right?

[felipeg, 2013/05/02 13:55:58]

I thought we agreed to leave it as a comment.

[gavinp, 2013/05/02 14:05:45]

Yeah. I am sorry for being unclear; I just want to make sure the discussion here
reflects that so future readers, if there ever are any, know what's up.

+  // we block until it actually created the files.
+  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_TRUE(entry != NULL);
+  entry->Close();
+  entry = NULL;
+
   // Delete one of the files in the entry.
   base::FilePath to_delete_file = cache_path_.AppendASCII(
       disk_cache::simple_util::GetFilenameFromKeyAndIndex(key, 0));
   EXPECT_TRUE(file_util::PathExists(to_delete_file));
   EXPECT_TRUE(disk_cache::DeleteCacheFile(to_delete_file));
 
   // Failing to open the entry should delete the rest of these files.
   ASSERT_EQ(net::ERR_FAILED, OpenEntry(key, &entry));
-
   // Confirm the rest of the files are gone.
   for (int i = 1; i < disk_cache::kSimpleEntryFileCount; ++i) {
     base::FilePath
         should_be_gone_file(cache_path_.AppendASCII(
             disk_cache::simple_util::GetFilenameFromKeyAndIndex(key, i)));
     EXPECT_FALSE(file_util::PathExists(should_be_gone_file));
   }
 }
 
 TEST_F(DiskCacheBackendTest, SimpleCacheOpenBadFile) {
   SetSimpleCacheMode();
   InitCache();
 
   const char* key = "the first key";
   disk_cache::Entry* entry = NULL;
 
   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
   disk_cache::Entry* null = NULL;
   ASSERT_NE(null, entry);
   entry->Close();
   entry = NULL;
 
+  // To make sure the file creation completed we need to call open again so that
+  // we block until it actually created the files.
+  ASSERT_EQ(net::OK, OpenEntry(key, &entry));
+  ASSERT_NE(null, entry);
+  entry->Close();
+  entry = NULL;
+
   // Write an invalid header on stream 1.
   base::FilePath entry_file1_path = cache_path_.AppendASCII(
       disk_cache::simple_util::GetFilenameFromKeyAndIndex(key, 1));
 
   disk_cache::SimpleFileHeader header;
   header.initial_magic_number = GG_UINT64_C(0xbadf00d);
   EXPECT_EQ(
       implicit_cast<int>(sizeof(header)),
       file_util::WriteFile(entry_file1_path, reinterpret_cast<char*>(&header),
                            sizeof(header)));
@@ skipping 77 matching lines @@
                                   NULL);
   cache->SetUnitTestMode();
   net::TestCompletionCallback cb;
   int rv = cache->Init(cb.callback());
   EXPECT_NE(net::OK, cb.GetResult(rv));
   delete cache;
   DisableIntegrityCheck();
 }
 
 #endif  // !defined(OS_WIN)