Remove MessageLoop::current()->RunUntilIdle() in net.

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 <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
@@ skipping 2135 matching lines @@
   entry1->Doom();
   entry1->Close();
   entry2->Close();
 
   // Doom the second entry after it's fully saved.
   EXPECT_EQ(net::OK, 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.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   if (memory_only_) {
     EXPECT_EQ(0, cache_->GetEntryCount());
   } 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.
       base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(500));
-      base::MessageLoop::current()->RunUntilIdle();
+      base::RunLoop().RunUntilIdle();
     }
     EXPECT_EQ(0, cache_->GetEntryCount());
   }
 }
 
 TEST_F(DiskCacheEntryTest, DoomSparseEntry) {
   UseCurrentThread();
   InitCache();
   DoomSparseEntry();
 }
@@ skipping 850 matching lines @@
 
   // 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(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();
+  base::RunLoop().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;
@@ skipping 153 matching lines @@
   EXPECT_EQ(net::OK, cb.GetResult(net::ERR_IO_PENDING));
 
   EXPECT_EQ(
       kSize1,
       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();
+  base::RunLoop().RunUntilIdle();
 
   for (int i = 0; i < disk_cache::kSimpleEntryFileCount; ++i) {
     base::FilePath entry_file_path = cache_path_.AppendASCII(
         disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, i));
     base::File::Info info;
     EXPECT_FALSE(base::GetFileInfo(entry_file_path, &info));
   }
 }
 
 TEST_F(DiskCacheEntryTest, SimpleCacheDoomCreateRace) {
@@ skipping 827 matching lines @@
   // Close does not have a callback. However, we need to be sure the close is
   // finished before we continue the test. We can take advantage of how the ref
   // counting of a SimpleEntryImpl works to fake out a callback: When the
   // last Close() call is made to an entry, an IO operation is sent to the
   // synchronous entry to close the platform files. This IO operation holds a
   // ref pointer to the entry, which expires when the operation is done. So,
   // we take a refpointer, and watch the SimpleEntry object until it has only
   // one ref; this indicates the IO operation is complete.
   while (!entry1_refptr->HasOneRef()) {
     base::PlatformThread::YieldCurrentThread();
-    base::MessageLoop::current()->RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
   entry1_refptr = NULL;
 
   // In the bug case, this new entry ends up being a duplicate object pointing
   // at the same underlying files.
   disk_cache::Entry* entry3 = NULL;
   EXPECT_EQ(net::OK, OpenEntry(key, &entry3));
   ScopedEntryPtr entry3_closer(entry3);
   EXPECT_NE(null, entry3);
 
@@ skipping 188 matching lines @@
   entry->Close();
 
   base::RunLoop().RunUntilIdle();
   disk_cache::SimpleBackendImpl::FlushWorkerPoolForTesting();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(
       disk_cache::simple_util::CorruptKeySHA256FromEntry(key, cache_path_));
   EXPECT_NE(net::OK, OpenEntry(key, &entry));
 }