Properly order the cc files based off the h files in base/.

base/process_util_linux.cc

 // Copyright (c) 2009 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_util.h"
 
 #include <ctype.h>
 #include <dirent.h>
 #include <dlfcn.h>
 #include <errno.h>
@@ skipping 50 matching lines @@
   cmd_line_file = cmd_line_file.Append("cmdline");
   std::string cmd_line;
   if (!file_util::ReadFileToString(cmd_line_file, &cmd_line))
     return false;
   std::string delimiters;
   delimiters.push_back('\0');
   Tokenize(cmd_line, delimiters, proc_cmd_line_args);
   return true;
 }
 
+// Get the total CPU of a single process.  Return value is number of jiffies
+// on success or -1 on error.
+int GetProcessCPU(pid_t pid) {
+  // Synchronously reading files in /proc is safe.
+  base::ThreadRestrictions::ScopedAllowIO allow_io;
+
+  // Use /proc/<pid>/task to find all threads and parse their /stat file.
+  FilePath path = FilePath(StringPrintf("/proc/%d/task/", pid));
+
+  DIR* dir = opendir(path.value().c_str());
+  if (!dir) {
+    PLOG(ERROR) << "opendir(" << path.value() << ")";
+    return -1;
+  }
+
+  int total_cpu = 0;
+  while (struct dirent* ent = readdir(dir)) {
+    if (ent->d_name[0] == '.')
+      continue;
+
+    FilePath stat_path = path.AppendASCII(ent->d_name).AppendASCII("stat");
+    std::string stat;
+    if (file_util::ReadFileToString(stat_path, &stat)) {
+      int cpu = base::ParseProcStatCPU(stat);
+      if (cpu > 0)
+        total_cpu += cpu;
+    }
+  }
+  closedir(dir);
+
+  return total_cpu;
+}
+
 }  // namespace
 
 namespace base {
 
 ProcessId GetParentProcessId(ProcessHandle process) {
   // Synchronously reading files in /proc is safe.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   FilePath stat_file("/proc");
   stat_file = stat_file.Append(base::IntToString(process));
@@ skipping 138 matching lines @@
   return true;
 }
 
 bool NamedProcessIterator::IncludeEntry() {
   if (executable_name_ != entry().exe_file())
     return false;
   return ProcessIterator::IncludeEntry();
 }
 
 
-ProcessMetrics::ProcessMetrics(ProcessHandle process)
-    : process_(process),
-      last_time_(0),
-      last_system_time_(0),
-      last_cpu_(0) {
-  processor_count_ = base::SysInfo::NumberOfProcessors();
-}
-
 // static
 ProcessMetrics* ProcessMetrics::CreateProcessMetrics(ProcessHandle process) {
   return new ProcessMetrics(process);
 }
 
 // On linux, we return vsize.
 size_t ProcessMetrics::GetPagefileUsage() const {
   std::vector<std::string> proc_stats;
   if (!GetProcStats(process_, &proc_stats))
     LOG(WARNING) << "Failed to get process stats.";
@@ skipping 145 matching lines @@
   ws_usage->priv = private_kb;
   // Sharable is not calculated, as it does not provide interesting data.
   ws_usage->shareable = 0;
 
   ws_usage->shared = 0;
   if (have_pss)
     ws_usage->shared = pss_kb;
   return true;
 }
 
+double ProcessMetrics::GetCPUUsage() {
+  // This queries the /proc-specific scaling factor which is
+  // conceptually the system hertz.  To dump this value on another
+  // system, try
+  //   od -t dL /proc/self/auxv
+  // and look for the number after 17 in the output; mine is
+  //   0000040          17         100           3   134512692
+  // which means the answer is 100.
+  // It may be the case that this value is always 100.
+  static const int kHertz = sysconf(_SC_CLK_TCK);
+
+  struct timeval now;
+  int retval = gettimeofday(&now, NULL);
+  if (retval)
+    return 0;
+  int64 time = TimeValToMicroseconds(now);
+
+  if (last_time_ == 0) {
+    // First call, just set the last values.
+    last_time_ = time;
+    last_cpu_ = GetProcessCPU(process_);
+    return 0;
+  }
+
+  int64 time_delta = time - last_time_;
+  DCHECK_NE(time_delta, 0);
+  if (time_delta == 0)
+    return 0;
+
+  int cpu = GetProcessCPU(process_);
+
+  // We have the number of jiffies in the time period.  Convert to percentage.
+  // Note this means we will go *over* 100 in the case where multiple threads
+  // are together adding to more than one CPU's worth.
+  int percentage = 100 * (cpu - last_cpu_) /
+      (kHertz * TimeDelta::FromMicroseconds(time_delta).InSecondsF());
+
+  last_time_ = time;
+  last_cpu_ = cpu;
+
+  return percentage;
+}
+
 // 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.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   std::string proc_io_contents;
   FilePath io_file("/proc");
   io_file = io_file.Append(base::IntToString(process_));
   io_file = io_file.Append("io");
@@ skipping 27 matching lines @@
           base::StringToInt64(tokenizer.token(),
               reinterpret_cast<int64*>(&(*io_counters).WriteTransferCount));
         }
         state = KEY_NAME;
         break;
     }
   }
   return true;
 }
 
+ProcessMetrics::ProcessMetrics(ProcessHandle process)
+    : process_(process),
+      last_time_(0),
+      last_system_time_(0),
+      last_cpu_(0) {
+  processor_count_ = base::SysInfo::NumberOfProcessors();
+}
+
 
 // Exposed for testing.
 int ParseProcStatCPU(const std::string& input) {
   // /proc/<pid>/stat contains the process name in parens.  In case the
   // process name itself contains parens, skip past them.
   std::string::size_type rparen = input.rfind(')');
   if (rparen == std::string::npos)
     return -1;
 
   // From here, we expect a bunch of space-separated fields, where the
   // 0-indexed 11th and 12th are utime and stime.  On two different machines
   // I found 42 and 39 fields, so let's just expect the ones we need.
   std::vector<std::string> fields;
   base::SplitString(input.substr(rparen + 2), ' ', &fields);
   if (fields.size() < 13)
     return -1;  // Output not in the format we expect.
 
   int fields11, fields12;
   base::StringToInt(fields[11], &fields11);
   base::StringToInt(fields[12], &fields12);
   return fields11 + fields12;
 }
 
-// Get the total CPU of a single process.  Return value is number of jiffies
-// on success or -1 on error.
-static int GetProcessCPU(pid_t pid) {
-  // Synchronously reading files in /proc is safe.
-  base::ThreadRestrictions::ScopedAllowIO allow_io;
-
-  // Use /proc/<pid>/task to find all threads and parse their /stat file.
-  FilePath path = FilePath(StringPrintf("/proc/%d/task/", pid));
-
-  DIR* dir = opendir(path.value().c_str());
-  if (!dir) {
-    PLOG(ERROR) << "opendir(" << path.value() << ")";
-    return -1;
-  }
-
-  int total_cpu = 0;
-  while (struct dirent* ent = readdir(dir)) {
-    if (ent->d_name[0] == '.')
-      continue;
-
-    FilePath stat_path = path.AppendASCII(ent->d_name).AppendASCII("stat");
-    std::string stat;
-    if (file_util::ReadFileToString(stat_path, &stat)) {
-      int cpu = ParseProcStatCPU(stat);
-      if (cpu > 0)
-        total_cpu += cpu;
-    }
-  }
-  closedir(dir);
-
-  return total_cpu;
-}
-
-double ProcessMetrics::GetCPUUsage() {
-  // This queries the /proc-specific scaling factor which is
-  // conceptually the system hertz.  To dump this value on another
-  // system, try
-  //   od -t dL /proc/self/auxv
-  // and look for the number after 17 in the output; mine is
-  //   0000040          17         100           3   134512692
-  // which means the answer is 100.
-  // It may be the case that this value is always 100.
-  static const int kHertz = sysconf(_SC_CLK_TCK);
-
-  struct timeval now;
-  int retval = gettimeofday(&now, NULL);
-  if (retval)
-    return 0;
-  int64 time = TimeValToMicroseconds(now);
-
-  if (last_time_ == 0) {
-    // First call, just set the last values.
-    last_time_ = time;
-    last_cpu_ = GetProcessCPU(process_);
-    return 0;
-  }
-
-  int64 time_delta = time - last_time_;
-  DCHECK_NE(time_delta, 0);
-  if (time_delta == 0)
-    return 0;
-
-  int cpu = GetProcessCPU(process_);
-
-  // We have the number of jiffies in the time period.  Convert to percentage.
-  // Note this means we will go *over* 100 in the case where multiple threads
-  // are together adding to more than one CPU's worth.
-  int percentage = 100 * (cpu - last_cpu_) /
-      (kHertz * TimeDelta::FromMicroseconds(time_delta).InSecondsF());
-
-  last_time_ = time;
-  last_cpu_ = cpu;
-
-  return percentage;
-}
-
 namespace {
 
 // The format of /proc/meminfo is:
 //
 // MemTotal:      8235324 kB
 // MemFree:       1628304 kB
 // Buffers:        429596 kB
 // Cached:        4728232 kB
 // ...
 const size_t kMemTotalIndex = 1;
@@ skipping 148 matching lines @@
 
   if (!file_util::PathExists(oom_adj))
     return false;
 
   std::string score_str = base::IntToString(score);
   return (static_cast<int>(score_str.length()) ==
           file_util::WriteFile(oom_adj, score_str.c_str(), score_str.length()));
 }
 
 }  // namespace base