Deflake SimpleIndexFileTest.WriteThenLoadIndex.

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 170 matching lines @@
   EXPECT_TRUE(base::TouchFile(cache_path, past_time, past_time));
   ASSERT_TRUE(simple_util::GetMTime(cache_path, &cache_mtime));
   EXPECT_FALSE(
       WrappedSimpleIndexFile::LegacyIsIndexFileStale(cache_mtime, index_path));
   const base::Time even_older = past_time - base::TimeDelta::FromSeconds(10);
   EXPECT_TRUE(base::TouchFile(index_path, even_older, even_older));
   EXPECT_TRUE(
       WrappedSimpleIndexFile::LegacyIsIndexFileStale(cache_mtime, index_path));
 }
 
-// This test is flaky, see http://crbug.com/255775.
-TEST_F(SimpleIndexFileTest, DISABLED_WriteThenLoadIndex) {
+TEST_F(SimpleIndexFileTest, WriteThenLoadIndex) {
   base::ScopedTempDir cache_dir;
   ASSERT_TRUE(cache_dir.CreateUniqueTempDir());
 
   SimpleIndex::EntrySet entries;
   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;
   {
     WrappedSimpleIndexFile simple_index_file(cache_dir.path());
     simple_index_file.WriteToDisk(entries, kCacheSize,
                                   base::TimeTicks(), false);
     base::RunLoop().RunUntilIdle();
     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(simple_index_file.GetIndexFilePath(),
-                                    &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(),
                                      &load_index_result);
   base::RunLoop().RunUntilIdle();
 
   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);
@@ skipping 103 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