Update from https://crrev.com/303153

net/disk_cache/simple/simple_index_file_unittest.cc

 // Copyright (c) 2011 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/files/file.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/hash.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 80 matching lines @@
 };
 
 class SimpleIndexFileTest : public testing::Test {
  public:
   bool CompareTwoEntryMetadata(const EntryMetadata& a, const EntryMetadata& b) {
     return
         a.last_used_time_seconds_since_epoch_ ==
             b.last_used_time_seconds_since_epoch_ &&
         a.entry_size_ == b.entry_size_;
   }
-
- protected:
-  SimpleIndexFileTest() : callback_called_(false) {}
-
-  base::Closure GetCallback() {
-    return base::Bind(&SimpleIndexFileTest::LoadIndexEntriesCallback,
-                      base::Unretained(this));
-  }
-
-  bool callback_called() { return callback_called_; }
-
- private:
-  void LoadIndexEntriesCallback() {
-    EXPECT_FALSE(callback_called_);
-    callback_called_ = true;
-  }
-
-  bool callback_called_;
 };
 
 TEST_F(SimpleIndexFileTest, Serialize) {
   SimpleIndex::EntrySet entries;
   static const uint64 kHashes[] = { 11, 22, 33 };
   static const size_t kNumHashes = arraysize(kHashes);
   EntryMetadata metadata_entries[kNumHashes];
 
   SimpleIndexFile::IndexMetadata index_metadata(static_cast<uint64>(kNumHashes),
                                                 456);
@@ skipping 67 matching lines @@
   static const uint64 kHashes[] = { 11, 22, 33 };
   static const size_t kNumHashes = arraysize(kHashes);
   EntryMetadata metadata_entries[kNumHashes];
   for (size_t i = 0; i < kNumHashes; ++i) {
     uint64 hash = kHashes[i];
     metadata_entries[i] = EntryMetadata(Time(), hash);
     SimpleIndex::InsertInEntrySet(hash, metadata_entries[i], &entries);
   }
 
   const uint64 kCacheSize = 456U;
+  net::TestClosure closure;
   {
     WrappedSimpleIndexFile simple_index_file(cache_dir.path());
-    simple_index_file.WriteToDisk(entries, kCacheSize,
-                                  base::TimeTicks(), false);
-    base::RunLoop().RunUntilIdle();
+    simple_index_file.WriteToDisk(entries, kCacheSize, base::TimeTicks(),
+                                  false, closure.closure());
+    closure.WaitForResult();
     EXPECT_TRUE(base::PathExists(simple_index_file.GetIndexFilePath()));
   }
 
   WrappedSimpleIndexFile simple_index_file(cache_dir.path());
   base::Time fake_cache_mtime;
   ASSERT_TRUE(simple_util::GetMTime(cache_dir.path(), &fake_cache_mtime));
   SimpleIndexLoadResult load_index_result;
-  simple_index_file.LoadIndexEntries(fake_cache_mtime,
-                                     GetCallback(),
+  simple_index_file.LoadIndexEntries(fake_cache_mtime, closure.closure(),
                                      &load_index_result);
-  base::RunLoop().RunUntilIdle();
+  closure.WaitForResult();
 
   EXPECT_TRUE(base::PathExists(simple_index_file.GetIndexFilePath()));
-  ASSERT_TRUE(callback_called());
   EXPECT_TRUE(load_index_result.did_load);
   EXPECT_FALSE(load_index_result.flush_required);
 
   EXPECT_EQ(kNumHashes, load_index_result.entries.size());
   for (size_t i = 0; i < kNumHashes; ++i)
     EXPECT_EQ(1U, load_index_result.entries.count(kHashes[i]));
 }
 
 TEST_F(SimpleIndexFileTest, LoadCorruptIndex) {
   base::ScopedTempDir cache_dir;
   ASSERT_TRUE(cache_dir.CreateUniqueTempDir());
 
   WrappedSimpleIndexFile simple_index_file(cache_dir.path());
   ASSERT_TRUE(simple_index_file.CreateIndexFileDirectory());
   const base::FilePath& index_path = simple_index_file.GetIndexFilePath();
   const std::string kDummyData = "nothing to be seen here";
   EXPECT_EQ(
       implicit_cast<int>(kDummyData.size()),
       base::WriteFile(index_path, kDummyData.data(), kDummyData.size()));
   base::Time fake_cache_mtime;
   ASSERT_TRUE(simple_util::GetMTime(simple_index_file.GetIndexFilePath(),
                                     &fake_cache_mtime));
   EXPECT_FALSE(WrappedSimpleIndexFile::LegacyIsIndexFileStale(fake_cache_mtime,
                                                               index_path));
-
   SimpleIndexLoadResult load_index_result;
-  simple_index_file.LoadIndexEntries(fake_cache_mtime,
-                                     GetCallback(),
+  net::TestClosure closure;
+  simple_index_file.LoadIndexEntries(fake_cache_mtime, closure.closure(),
                                      &load_index_result);
-  base::RunLoop().RunUntilIdle();
+  closure.WaitForResult();
 
   EXPECT_FALSE(base::PathExists(index_path));
-  ASSERT_TRUE(callback_called());
   EXPECT_TRUE(load_index_result.did_load);
   EXPECT_TRUE(load_index_result.flush_required);
 }
 
 // Tests that after an upgrade the backend has the index file put in place.
 TEST_F(SimpleIndexFileTest, SimpleCacheUpgrade) {
   base::ScopedTempDir cache_dir;
   ASSERT_TRUE(cache_dir.CreateUniqueTempDir());
   const base::FilePath cache_path = cache_dir.path();
 
@@ skipping 62 matching lines @@
   WrappedSimpleIndexFile::Deserialize(contents.data(),
                                       contents.size(),
                                       &when_index_last_saw_cache,
                                       &deserialize_result);
   EXPECT_TRUE(deserialize_result.did_load);
 }
 
 #endif  // defined(OS_POSIX)
 
 }  // namespace disk_cache