Move WriteFile and WriteFileDescriptor from file_util to base namespace.

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/file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/hash.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 152 matching lines @@
   const base::FilePath cache_path = cache_dir.path();
 
   ASSERT_TRUE(simple_util::GetMTime(cache_path, &cache_mtime));
   WrappedSimpleIndexFile simple_index_file(cache_path);
   ASSERT_TRUE(simple_index_file.CreateIndexFileDirectory());
   const base::FilePath& index_path = simple_index_file.GetIndexFilePath();
   EXPECT_TRUE(
       WrappedSimpleIndexFile::LegacyIsIndexFileStale(cache_mtime, 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()));
+            base::WriteFile(index_path,
+                            kDummyData.data(), kDummyData.size()));
   ASSERT_TRUE(simple_util::GetMTime(cache_path, &cache_mtime));
   EXPECT_FALSE(
       WrappedSimpleIndexFile::LegacyIsIndexFileStale(cache_mtime, index_path));
 
   const base::Time past_time = base::Time::Now() -
       base::TimeDelta::FromSeconds(10);
   EXPECT_TRUE(base::TouchFile(index_path, past_time, past_time));
   EXPECT_TRUE(base::TouchFile(cache_path, past_time, past_time));
   ASSERT_TRUE(simple_util::GetMTime(cache_path, &cache_mtime));
   EXPECT_FALSE(
@@ skipping 51 matching lines @@
 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()),
-      file_util::WriteFile(index_path, kDummyData.data(), 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(),
                                      &load_index_result);
@@ skipping 22 matching lines @@
                                  sizeof(file_contents));
   ASSERT_EQ((int)sizeof(file_contents), bytes_written);
   file.Close();
 
   // Write the index file. The format is incorrect, but for transitioning from
   // v5 it does not matter.
   const std::string index_file_contents("incorrectly serialized data");
   const base::FilePath old_index_file =
       cache_path.AppendASCII("the-real-index");
   ASSERT_EQ(implicit_cast<int>(index_file_contents.size()),
-            file_util::WriteFile(old_index_file,
-                                 index_file_contents.data(),
-                                 index_file_contents.size()));
+            base::WriteFile(old_index_file,
+                            index_file_contents.data(),
+                            index_file_contents.size()));
 
   // Upgrade the cache.
   ASSERT_TRUE(disk_cache::UpgradeSimpleCacheOnDisk(cache_path));
 
   // Create the backend and initiate index flush by destroying the backend.
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
   disk_cache::SimpleBackendImpl* simple_cache =
       new disk_cache::SimpleBackendImpl(cache_path,
@@ skipping 31 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