Move ReadFileToString to the base namespace.

base/process/process_metrics_linux.cc

 // Copyright (c) 2013 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/process/process_metrics.h"
 
 #include <dirent.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/time.h>
@@ skipping 16 matching lines @@
 
 enum ParsingState {
   KEY_NAME,
   KEY_VALUE
 };
 
 #ifdef OS_CHROMEOS
 // Read a file with a single number string and return the number as a uint64.
 static uint64 ReadFileToUint64(const base::FilePath file) {
   std::string file_as_string;
-  if (!file_util::ReadFileToString(file, &file_as_string))
+  if (!ReadFileToString(file, &file_as_string))
     return 0;
   TrimWhitespaceASCII(file_as_string, TRIM_ALL, &file_as_string);
   uint64 file_as_uint64 = 0;
   if (!base::StringToUint64(file_as_string, &file_as_uint64))
     return 0;
   return file_as_uint64;
 }
 #endif
 
 // Read /proc/<pid>/status and returns the value for |field|, or 0 on failure.
 // Only works for fields in the form of "Field: value kB".
 size_t ReadProcStatusAndGetFieldAsSizeT(pid_t pid, const std::string& field) {
   FilePath stat_file = internal::GetProcPidDir(pid).Append("status");
   std::string status;
   {
     // Synchronously reading files in /proc is safe.
     ThreadRestrictions::ScopedAllowIO allow_io;
-    if (!file_util::ReadFileToString(stat_file, &status))
+    if (!ReadFileToString(stat_file, &status))
       return 0;
   }
 
   StringTokenizer tokenizer(status, ":\n");
   ParsingState state = KEY_NAME;
   StringPiece last_key_name;
   while (tokenizer.GetNext()) {
     switch (state) {
       case KEY_NAME:
         last_key_name = tokenizer.token_piece();
@@ skipping 44 matching lines @@
     pid_t tid = internal::ProcDirSlotToPid(ent->d_name);
     if (!tid)
       continue;
 
     // Synchronously reading files in /proc is safe.
     ThreadRestrictions::ScopedAllowIO allow_io;
 
     std::string stat;
     FilePath stat_path =
         task_path.Append(ent->d_name).Append(internal::kStatFile);
-    if (file_util::ReadFileToString(stat_path, &stat)) {
+    if (ReadFileToString(stat_path, &stat)) {
       int cpu = ParseProcStatCPU(stat);
       if (cpu > 0)
         total_cpu += cpu;
     }
   }
   closedir(dir);
 
   return total_cpu;
 }
 
@@ skipping 85 matching lines @@
 }
 
 // To have /proc/self/io file you must enable CONFIG_TASK_IO_ACCOUNTING
 // in your kernel configuration.
 bool ProcessMetrics::GetIOCounters(IoCounters* io_counters) const {
   // Synchronously reading files in /proc is safe.
   ThreadRestrictions::ScopedAllowIO allow_io;
 
   std::string proc_io_contents;
   FilePath io_file = internal::GetProcPidDir(process_).Append("io");
-  if (!file_util::ReadFileToString(io_file, &proc_io_contents))
+  if (!ReadFileToString(io_file, &proc_io_contents))
     return false;
 
   (*io_counters).OtherOperationCount = 0;
   (*io_counters).OtherTransferCount = 0;
 
   StringTokenizer tokenizer(proc_io_contents, ": \n");
   ParsingState state = KEY_NAME;
   StringPiece last_key_name;
   while (tokenizer.GetNext()) {
     switch (state) {
@@ skipping 51 matching lines @@
   // Locked:              XXX kB
   const size_t kPssIndex = (1 * 3) + 1;
   const size_t kPrivate_CleanIndex = (4 * 3) + 1;
   const size_t kPrivate_DirtyIndex = (5 * 3) + 1;
   const size_t kSwapIndex = (9 * 3) + 1;
 
   std::string totmaps_data;
   {
     FilePath totmaps_file = internal::GetProcPidDir(process_).Append("totmaps");
     ThreadRestrictions::ScopedAllowIO allow_io;
-    bool ret = file_util::ReadFileToString(totmaps_file, &totmaps_data);
+    bool ret = ReadFileToString(totmaps_file, &totmaps_data);
     if (!ret || totmaps_data.length() == 0)
       return false;
   }
 
   std::vector<std::string> totmaps_fields;
   SplitStringAlongWhitespace(totmaps_data, &totmaps_fields);
 
   DCHECK_EQ("Pss:", totmaps_fields[kPssIndex-1]);
   DCHECK_EQ("Private_Clean:", totmaps_fields[kPrivate_CleanIndex - 1]);
   DCHECK_EQ("Private_Dirty:", totmaps_fields[kPrivate_DirtyIndex - 1]);
@@ skipping 31 matching lines @@
   // For details, see: man 5 proc.
   const int page_size_kb = getpagesize() / 1024;
   if (page_size_kb <= 0)
     return false;
 
   std::string statm;
   {
     FilePath statm_file = internal::GetProcPidDir(process_).Append("statm");
     // Synchronously reading files in /proc is safe.
     ThreadRestrictions::ScopedAllowIO allow_io;
-    bool ret = file_util::ReadFileToString(statm_file, &statm);
+    bool ret = ReadFileToString(statm_file, &statm);
     if (!ret || statm.length() == 0)
       return false;
   }
 
   std::vector<std::string> statm_vec;
   SplitString(statm, ' ', &statm_vec);
   if (statm_vec.size() != 7)
     return false;  // Not the format we expect.
 
   int statm_rss, statm_shared;
@@ skipping 76 matching lines @@
       gem_size(-1) {
 }
 
 bool GetSystemMemoryInfo(SystemMemoryInfoKB* meminfo) {
   // Synchronously reading files in /proc is safe.
   ThreadRestrictions::ScopedAllowIO allow_io;
 
   // Used memory is: total - free - buffers - caches
   FilePath meminfo_file("/proc/meminfo");
   std::string meminfo_data;
-  if (!file_util::ReadFileToString(meminfo_file, &meminfo_data)) {
+  if (!ReadFileToString(meminfo_file, &meminfo_data)) {
     DLOG(WARNING) << "Failed to open " << meminfo_file.value();
     return false;
   }
   std::vector<std::string> meminfo_fields;
   SplitStringAlongWhitespace(meminfo_data, &meminfo_fields);
 
   if (meminfo_fields.size() < kMemCachedIndex) {
     DLOG(WARNING) << "Failed to parse " << meminfo_file.value()
                   << ".  Only found " << meminfo_fields.size() << " fields.";
     return false;
@@ skipping 34 matching lines @@
   // bind mount into /sys/kernel/debug and synchronously reading the in-memory
   // files in /sys is fast.
 #if defined(ARCH_CPU_ARM_FAMILY)
   FilePath geminfo_file("/var/run/debugfs_gpu/exynos_gem_objects");
 #else
   FilePath geminfo_file("/var/run/debugfs_gpu/i915_gem_objects");
 #endif
   std::string geminfo_data;
   meminfo->gem_objects = -1;
   meminfo->gem_size = -1;
-  if (file_util::ReadFileToString(geminfo_file, &geminfo_data)) {
+  if (ReadFileToString(geminfo_file, &geminfo_data)) {
     int gem_objects = -1;
     long long gem_size = -1;
     int num_res = sscanf(geminfo_data.c_str(),
                          "%d objects, %lld bytes",
                          &gem_objects, &gem_size);
     if (num_res == 2) {
       meminfo->gem_objects = gem_objects;
       meminfo->gem_size = gem_size;
     }
   }
 
 #if defined(ARCH_CPU_ARM_FAMILY)
   // Incorporate Mali graphics memory if present.
   FilePath mali_memory_file("/sys/devices/platform/mali.0/memory");
   std::string mali_memory_data;
-  if (file_util::ReadFileToString(mali_memory_file, &mali_memory_data)) {
+  if (ReadFileToString(mali_memory_file, &mali_memory_data)) {
     long long mali_size = -1;
     int num_res = sscanf(mali_memory_data.c_str(), "%lld bytes", &mali_size);
     if (num_res == 1)
       meminfo->gem_size += mali_size;
   }
 #endif  // defined(ARCH_CPU_ARM_FAMILY)
 #endif  // defined(OS_CHROMEOS)
 
   return true;
 }
@@ skipping 19 matching lines @@
   swap_info->num_reads = ReadFileToUint64(zram_path.Append("num_reads"));
   swap_info->num_writes = ReadFileToUint64(zram_path.Append("num_writes"));
   swap_info->compr_data_size =
       ReadFileToUint64(zram_path.Append("compr_data_size"));
   swap_info->mem_used_total =
       ReadFileToUint64(zram_path.Append("mem_used_total"));
 }
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace base