Disk cache: Reduce the chance of failing a unit test under Posix....

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 129 matching lines @@
   CacheTestFillBuffer(buffer3->data(), kSize3, false);
 
   EXPECT_EQ(0, entry1->ReadData(0, 15 * 1024, buffer1, kSize1, &callback1));
   base::strlcpy(buffer1->data(), "the data", kSize1);
   int expected = 0;
   int ret = entry1->WriteData(0, 0, buffer1, kSize1, &callback2, false);
   EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
-  memset(buffer2->data(), 0, kSize1);
+  EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
+  memset(buffer2->data(), 0, kSize2);
   ret = entry1->ReadData(0, 0, buffer2, kSize1, &callback3);
   EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
   EXPECT_STREQ("the data", buffer2->data());
 
   base::strlcpy(buffer2->data(), "The really big data goes here", kSize2);
   ret = entry1->WriteData(1, 1500, buffer2, kSize2, &callback4, true);
   EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
-  memset(buffer3->data(), 0, kSize2);
+  EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
+  memset(buffer3->data(), 0, kSize3);
   ret = entry1->ReadData(1, 1511, buffer3, kSize2, &callback5);
   EXPECT_TRUE(4989 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
   EXPECT_STREQ("big data goes here", buffer3->data());
   ret = entry1->ReadData(1, 0, buffer2, kSize2, &callback6);
   EXPECT_TRUE(5000 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
@@ skipping 11 matching lines @@
   ret = entry1->ReadData(1, 0, buffer3, kSize3, &callback9);
   EXPECT_TRUE(6500 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   ret = entry1->WriteData(1, 0, buffer3, 8192, &callback10, true);
   EXPECT_TRUE(8192 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
+  EXPECT_TRUE(helper.WaitUntilCacheIoFinished(expected));
   ret = entry1->ReadData(1, 0, buffer3, kSize3, &callback11);
   EXPECT_TRUE(8192 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
     expected++;
 
   EXPECT_EQ(8192, entry1->GetDataSize(1));
 
   ret = entry1->ReadData(0, 0, buffer1, kSize1, &callback12);
   EXPECT_TRUE(10 == ret || net::ERR_IO_PENDING == ret);
   if (net::ERR_IO_PENDING == ret)
@@ skipping 966 matching lines @@
   entry2->Close();
 
   // Doom the second entry after it's fully saved.
   EXPECT_TRUE(cache_->DoomEntry(key2));
 
   // Make sure we do all needed work. This may fail for entry2 if between Close
   // and DoomEntry the system decides to remove all traces of the file from the
   // system cache so we don't see that there is pending IO.
   MessageLoop::current()->RunAllPending();
 
-  if (memory_only_)
+  if (memory_only_) {
     EXPECT_EQ(0, cache_->GetEntryCount());
-  else
+  } else {
+    if (5 == cache_->GetEntryCount()) {
+      // Most likely we are waiting for the result of reading the sparse info
+      // (it's always async on Posix so it is easy to miss). Unfortunately we
+      // don't have any signal to watch for so we can only wait.
+      PlatformThread::Sleep(500);
+      MessageLoop::current()->RunAllPending();
+    }
     EXPECT_EQ(0, cache_->GetEntryCount());
+  }
 }
 
 TEST_F(DiskCacheEntryTest, DoomSparseEntry) {
   InitCache();
   DoomSparseEntry();
 }
 
 TEST_F(DiskCacheEntryTest, DISABLED_MemoryOnlyDoomSparseEntry) {
   SetMemoryOnlyMode();
   InitCache();
@@ skipping 108 matching lines @@
   EXPECT_EQ(kSize, entry->WriteSparseData(k1Meg + 16384, buf1, kSize, NULL));
   EXPECT_EQ(0, entry->ReadSparseData(k1Meg + 8192, buf1, kSize, NULL));
 
   // We never touched this one.
   EXPECT_EQ(kSize, entry->ReadSparseData(8192, buf1, kSize, NULL));
   entry->Close();
 
   // We re-created one of the corrupt children.
   EXPECT_EQ(3, cache_->GetEntryCount());
 }