Move WriteFile and WriteFileDescriptor from file_util to base namespace.

net/disk_cache/backend_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 "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/port.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 464 matching lines @@
 }
 
 TEST_F(DiskCacheBackendTest, ExternalFiles) {
   InitCache();
   // First, let's create a file on the folder.
   base::FilePath filename = cache_path_.AppendASCII("f_000001");
 
   const int kSize = 50;
   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer1->data(), kSize, false);
-  ASSERT_EQ(kSize, file_util::WriteFile(filename, buffer1->data(), kSize));
+  ASSERT_EQ(kSize, base::WriteFile(filename, buffer1->data(), kSize));
 
   // Now let's create a file with the cache.
   disk_cache::Entry* entry;
   ASSERT_EQ(net::OK, CreateEntry("key", &entry));
   ASSERT_EQ(0, WriteData(entry, 0, 20000, buffer1.get(), 0, false));
   entry->Close();
 
   // And verify that the first file is still there.
   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
   ASSERT_EQ(kSize, base::ReadFile(filename, buffer2->data(), kSize));
@@ skipping 168 matching lines @@
   // The integrity test sets kNoRandom so there's a version mismatch if we don't
   // force new eviction.
   SetNewEviction();
   BackendShutdownWithPendingCreate(true);
 }
 #endif
 
 TEST_F(DiskCacheTest, TruncatedIndex) {
   ASSERT_TRUE(CleanupCacheDir());
   base::FilePath index = cache_path_.AppendASCII("index");
-  ASSERT_EQ(5, file_util::WriteFile(index, "hello", 5));
+  ASSERT_EQ(5, base::WriteFile(index, "hello", 5));
 
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
   net::TestCompletionCallback cb;
 
   scoped_ptr<disk_cache::Backend> backend;
   int rv =
       disk_cache::CreateCacheBackend(net::DISK_CACHE,
                                      net::CACHE_BACKEND_BLOCKFILE,
@@ skipping 2625 matching lines @@
   entry = NULL;
 
   // Write an invalid header for stream 0 and stream 1.
   base::FilePath entry_file1_path = cache_path_.AppendASCII(
       disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, 0));
 
   disk_cache::SimpleFileHeader header;
   header.initial_magic_number = GG_UINT64_C(0xbadf00d);
   EXPECT_EQ(
       implicit_cast<int>(sizeof(header)),
-      file_util::WriteFile(entry_file1_path, reinterpret_cast<char*>(&header),
+      base::WriteFile(entry_file1_path, reinterpret_cast<char*>(&header),
                            sizeof(header)));
   ASSERT_EQ(net::ERR_FAILED, OpenEntry(key, &entry));
 }
 
 // Tests that the Simple Cache Backend fails to initialize with non-matching
 // file structure on disk.
 TEST_F(DiskCacheBackendTest, SimpleCacheOverBlockfileCache) {
   // Create a cache structure with the |BackendImpl|.
   InitCache();
   disk_cache::Entry* entry;
@@ skipping 157 matching lines @@
   void* iter = NULL;
   size_t count = 0;
   ASSERT_TRUE(EnumerateAndMatchKeys(-1, &iter, &keys_to_match, &count));
   cache_->EndEnumeration(&iter);
 
   EXPECT_EQ(key_pool.size(), count);
   EXPECT_TRUE(keys_to_match.empty());
 }
 
 #endif  // defined(OS_POSIX)