Remove simple_util::GetMTime from simple cache.

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/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/hash.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 118 matching lines @@
   for (size_t i = 0; i < kNumHashes; ++i) {
     SimpleIndex::EntrySet::const_iterator it = new_entries.find(kHashes[i]);
     EXPECT_TRUE(new_entries.end() != it);
     EXPECT_TRUE(CompareTwoEntryMetadata(it->second, metadata_entries[i]));
   }
 }
 
 TEST_F(SimpleIndexFileTest, IsIndexFileStale) {
   base::ScopedTempDir cache_dir;
   ASSERT_TRUE(cache_dir.CreateUniqueTempDir());
-  base::Time cache_mtime;
+  base::PlatformFileInfo file_info;
   const base::FilePath cache_path = cache_dir.path();
 
-  ASSERT_TRUE(simple_util::GetMTime(cache_path, &cache_mtime));
+  ASSERT_TRUE(file_util::GetFileInfo(cache_path, &file_info));
   WrappedSimpleIndexFile simple_index_file(cache_path);
   const base::FilePath& index_path = simple_index_file.GetIndexFilePath();
-  EXPECT_TRUE(WrappedSimpleIndexFile::IsIndexFileStale(cache_mtime,
+  EXPECT_TRUE(WrappedSimpleIndexFile::IsIndexFileStale(file_info.last_modified,
                                                        index_path));
   const std::string kDummyData = "nothing to be seen here";
   EXPECT_EQ(static_cast<int>(kDummyData.size()),
             file_util::WriteFile(index_path,
                                  kDummyData.data(),
                                  kDummyData.size()));
-  ASSERT_TRUE(simple_util::GetMTime(cache_path, &cache_mtime));
-  EXPECT_FALSE(WrappedSimpleIndexFile::IsIndexFileStale(cache_mtime,
+  ASSERT_TRUE(file_util::GetFileInfo(cache_path, &file_info));
+  EXPECT_FALSE(WrappedSimpleIndexFile::IsIndexFileStale(file_info.last_modified,
                                                         index_path));
 
   const base::Time past_time = base::Time::Now() -
       base::TimeDelta::FromSeconds(10);
   EXPECT_TRUE(file_util::TouchFile(index_path, past_time, past_time));
   EXPECT_TRUE(file_util::TouchFile(cache_path, past_time, past_time));
-  ASSERT_TRUE(simple_util::GetMTime(cache_path, &cache_mtime));
-  EXPECT_FALSE(WrappedSimpleIndexFile::IsIndexFileStale(cache_mtime,
+  ASSERT_TRUE(file_util::GetFileInfo(cache_path, &file_info));
+  EXPECT_FALSE(WrappedSimpleIndexFile::IsIndexFileStale(file_info.last_modified,
                                                         index_path));
   const base::Time even_older =
       past_time - base::TimeDelta::FromSeconds(10);
   EXPECT_TRUE(file_util::TouchFile(index_path, even_older, even_older));
-  EXPECT_TRUE(WrappedSimpleIndexFile::IsIndexFileStale(cache_mtime,
+  EXPECT_TRUE(WrappedSimpleIndexFile::IsIndexFileStale(file_info.last_modified,
                                                        index_path));
 
 }
 
 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));
+  base::PlatformFileInfo file_info;
+  ASSERT_TRUE(file_util::GetFileInfo(simple_index_file.GetIndexFilePath(),
+                                     &file_info));
   SimpleIndexLoadResult load_index_result;
-  simple_index_file.LoadIndexEntries(fake_cache_mtime,
+  simple_index_file.LoadIndexEntries(file_info.last_modified,
                                      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);
 
   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());
   const base::FilePath& index_path = simple_index_file.GetIndexFilePath();
   const std::string kDummyData = "nothing to be seen here";
   EXPECT_EQ(static_cast<int>(kDummyData.size()),
             file_util::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::IsIndexFileStale(fake_cache_mtime,
+  base::PlatformFileInfo file_info;
+  ASSERT_TRUE(file_util::GetFileInfo(simple_index_file.GetIndexFilePath(),
+                                     &file_info));
+  EXPECT_FALSE(WrappedSimpleIndexFile::IsIndexFileStale(file_info.last_modified,
                                                         index_path));
 
   SimpleIndexLoadResult load_index_result;
-  simple_index_file.LoadIndexEntries(fake_cache_mtime,
+  simple_index_file.LoadIndexEntries(file_info.last_modified,
                                      GetCallback(),
                                      &load_index_result);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(base::PathExists(index_path));
   ASSERT_TRUE(callback_called());
   EXPECT_TRUE(load_index_result.did_load);
   EXPECT_TRUE(load_index_result.flush_required);
 }
 
 }  // namespace disk_cache