Move GetFileSize, NormalizeFilePath to base namespace

chrome/browser/safe_browsing/safe_browsing_store_file.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 "chrome/browser/safe_browsing/safe_browsing_store_file.h"
 
 #include "base/md5.h"
 #include "base/metrics/histogram.h"
 
 namespace {
@@ skipping 117 matching lines @@
       chunks->erase(prev);
   }
 }
 
 // Sanity-check the header against the file's size to make sure our
 // vectors aren't gigantic.  This doubles as a cheap way to detect
 // corruption without having to checksum the entire file.
 bool FileHeaderSanityCheck(const base::FilePath& filename,
                            const FileHeader& header) {
   int64 size = 0;
-  if (!file_util::GetFileSize(filename, &size))
+  if (!base::GetFileSize(filename, &size))
     return false;
 
   int64 expected_size = sizeof(FileHeader);
   expected_size += header.add_chunk_count * sizeof(int32);
   expected_size += header.sub_chunk_count * sizeof(int32);
   expected_size += header.add_prefix_count * sizeof(SBAddPrefix);
   expected_size += header.sub_prefix_count * sizeof(SBSubPrefix);
   expected_size += header.add_hash_count * sizeof(SBAddFullHash);
   expected_size += header.sub_hash_count * sizeof(SBSubFullHash);
   expected_size += sizeof(base::MD5Digest);
@@ skipping 25 matching lines @@
   UMA_HISTOGRAM_ENUMERATION("SB2.FormatEvent", event_type, FORMAT_EVENT_MAX);
 }
 
 // static
 void SafeBrowsingStoreFile::CheckForOriginalAndDelete(
     const base::FilePath& current_filename) {
   const base::FilePath original_filename(
       current_filename.DirName().AppendASCII("Safe Browsing"));
   if (base::PathExists(original_filename)) {
     int64 size = 0;
-    if (file_util::GetFileSize(original_filename, &size)) {
+    if (base::GetFileSize(original_filename, &size)) {
       UMA_HISTOGRAM_COUNTS("SB2.OldDatabaseKilobytes",
                            static_cast<int>(size / 1024));
     }
 
     if (base::DeleteFile(original_filename, false)) {
       RecordFormatEvent(FORMAT_EVENT_DELETED_ORIGINAL);
     } else {
       RecordFormatEvent(FORMAT_EVENT_DELETED_ORIGINAL_FAILED);
     }
 
@@ skipping 28 matching lines @@
   // presumed not to be invalid.  The never-opened case can happen if
   // BeginUpdate() fails for any databases, and should already have
   // caused the corruption callback to fire.
   if (!file_.get())
     return true;
 
   if (!FileRewind(file_.get()))
     return OnCorruptDatabase();
 
   int64 size = 0;
-  if (!file_util::GetFileSize(filename_, &size))
+  if (!base::GetFileSize(filename_, &size))
     return OnCorruptDatabase();
 
   base::MD5Context context;
   base::MD5Init(&context);
 
   // Read everything except the final digest.
   size_t bytes_left = static_cast<size_t>(size);
   CHECK(size == static_cast<int64>(bytes_left));
   if (bytes_left < sizeof(base::MD5Digest))
     return OnCorruptDatabase();
@@ skipping 296 matching lines @@
     file_.reset();
   }
   DCHECK(!file_.get());
 
   // Rewind the temporary storage.
   if (!FileRewind(new_file_.get()))
     return false;
 
   // Get chunk file's size for validating counts.
   int64 size = 0;
-  if (!file_util::GetFileSize(TemporaryFileForFilename(filename_), &size))
+  if (!base::GetFileSize(TemporaryFileForFilename(filename_), &size))
     return OnCorruptDatabase();
 
   // Track update size to answer questions at http://crbug.com/72216 .
   // Log small updates as 1k so that the 0 (underflow) bucket can be
   // used for "empty" in SafeBrowsingDatabase.
   UMA_HISTOGRAM_COUNTS("SB2.DatabaseUpdateKilobytes",
                        std::max(static_cast<int>(size / 1024), 1));
 
   // Append the accumulated chunks onto the vectors read from |file_|.
   for (int i = 0; i < chunks_written_; ++i) {
@@ skipping 181 matching lines @@
   // With SQLite support gone, one way to get to this code is if the
   // existing file is a SQLite file.  Make sure the journal file is
   // also removed.
   const base::FilePath journal_filename(
       basename.value() + FILE_PATH_LITERAL("-journal"));
   if (base::PathExists(journal_filename))
     base::DeleteFile(journal_filename, false);
 
   return true;
 }