Move more file_util functions to base namespace.

components/visitedlink/browser/visitedlink_master.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 "components/visitedlink/browser/visitedlink_master.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <io.h>
 #include <shlobj.h>
@@ skipping 13 matching lines @@
 #include "base/strings/string_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "components/visitedlink/browser/visitedlink_delegate.h"
 #include "components/visitedlink/browser/visitedlink_event_listener.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "url/gurl.h"
 
 using content::BrowserThread;
 using file_util::ScopedFILE;
-using file_util::OpenFile;
-using file_util::TruncateFile;
 
 namespace visitedlink {
 
 const int32 VisitedLinkMaster::kFileHeaderSignatureOffset = 0;
 const int32 VisitedLinkMaster::kFileHeaderVersionOffset = 4;
 const int32 VisitedLinkMaster::kFileHeaderLengthOffset = 8;
 const int32 VisitedLinkMaster::kFileHeaderUsedOffset = 12;
 const int32 VisitedLinkMaster::kFileHeaderSaltOffset = 16;
 
 const int32 VisitedLinkMaster::kFileCurrentVersion = 3;
@@ skipping 15 matching lines @@
 // It is not necessary to generate a cryptographically strong random string,
 // only that it be reasonably different for different users.
 void GenerateSalt(uint8 salt[LINK_SALT_LENGTH]) {
   DCHECK_EQ(LINK_SALT_LENGTH, 8) << "This code assumes the length of the salt";
   uint64 randval = base::RandUint64();
   memcpy(salt, &randval, 8);
 }
 
 // Opens file on a background thread to not block UI thread.
 void AsyncOpen(FILE** file, const base::FilePath& filename) {
-  *file = OpenFile(filename, "wb+");
+  *file = base::OpenFile(filename, "wb+");
   DLOG_IF(ERROR, !(*file)) << "Failed to open file " << filename.value();
 }
 
 // Returns true if the write was complete.
 static bool WriteToFile(FILE* file,
                         off_t offset,
                         const void* data,
                         size_t data_len) {
   if (fseek(file, offset, SEEK_SET) != 0)
     return false;  // Don't write to an invalid part of the file.
@@ skipping 16 matching lines @@
 void AsyncWrite(FILE** file, int32 offset, const std::string& data) {
   if (*file)
     WriteToFile(*file, offset, data.data(), data.size());
 }
 
 // Truncates the file to the current position asynchronously on a background
 // thread. Double pointer to FILE is used because file may still not be opened
 // by the time of scheduling the task for execution.
 void AsyncTruncate(FILE** file) {
   if (*file)
-    base::IgnoreResult(TruncateFile(*file));
+    base::IgnoreResult(base::TruncateFile(*file));
 }
 
 // Closes the file on a background thread and releases memory used for storage
 // of FILE* value. Double pointer to FILE is used because file may still not
 // be opened by the time of scheduling the task for execution.
 void AsyncClose(FILE** file) {
   if (*file)
     base::IgnoreResult(fclose(*file));
   free(file);
 }
@@ skipping 416 matching lines @@
   // The hash table may have shrunk, so make sure this is the end.
   PostIOTask(FROM_HERE, base::Bind(&AsyncTruncate, file_));
 }
 
 bool VisitedLinkMaster::InitFromFile() {
   DCHECK(file_ == NULL);
   DCHECK(persist_to_disk_);
 
   base::FilePath filename;
   GetDatabaseFileName(&filename);
-  ScopedFILE file_closer(OpenFile(filename, "rb+"));
+  ScopedFILE file_closer(base::OpenFile(filename, "rb+"));
   if (!file_closer.get())
     return false;
 
   int32 num_entries, used_count;
   if (!ReadFileHeader(file_closer.get(), &num_entries, &used_count, salt_))
     return false;  // Header isn't valid.
 
   // Allocate and read the table.
   if (!CreateURLTable(num_entries, false))
     return false;
@@ skipping 424 matching lines @@
       BrowserThread::UI, FROM_HERE,
       base::Bind(&TableBuilder::OnCompleteMainThread, this));
 }
 
 void VisitedLinkMaster::TableBuilder::OnCompleteMainThread() {
   if (master_)
     master_->OnTableRebuildComplete(success_, fingerprints_);
 }
 
 }  // namespace visitedlink