Cleanup bits of base::ProcessMetrics.

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>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/process/internal_linux.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
 #include "base/threading/thread_restrictions.h"
 
 namespace base {
 
 namespace {
 
-enum ParsingState {
-  KEY_NAME,
-  KEY_VALUE
-};
-
-#ifdef OS_CHROMEOS
+#if defined(OS_CHROMEOS)
 // Read a file with a single number string and return the number as a uint64.
-static uint64 ReadFileToUint64(const base::FilePath file) {
+static uint64 ReadFileToUint64(const FilePath file) {
   std::string file_as_string;
   if (!ReadFileToString(file, &file_as_string))
     return 0;
-  base::TrimWhitespaceASCII(file_as_string, base::TRIM_ALL, &file_as_string);
+  TrimWhitespaceASCII(file_as_string, TRIM_ALL, &file_as_string);
   uint64 file_as_uint64 = 0;
-  if (!base::StringToUint64(file_as_string, &file_as_uint64))
+  if (!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.
+// Read /proc/<pid>/status and return 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;
+    FilePath stat_file = internal::GetProcPidDir(pid).Append("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();
-        state = KEY_VALUE;
-        break;
-      case KEY_VALUE:
-        DCHECK(!last_key_name.empty());
-        if (last_key_name == field) {
-          std::string value_str;
-          tokenizer.token_piece().CopyToString(&value_str);
-          std::string value_str_trimmed;
-          base::TrimWhitespaceASCII(value_str, base::TRIM_ALL,
-                                    &value_str_trimmed);
-          std::vector<std::string> split_value_str;
-          SplitString(value_str_trimmed, ' ', &split_value_str);
-          if (split_value_str.size() != 2 || split_value_str[1] != "kB") {
-            NOTREACHED();
-            return 0;
-          }
-          size_t value;
-          if (!StringToSizeT(split_value_str[0], &value)) {
-            NOTREACHED();
-            return 0;
-          }
-          return value;
-        }
-        state = KEY_NAME;
-        break;
+  std::vector<std::pair<std::string, std::string> > pairs;
+  SplitStringIntoKeyValuePairs(status, ':', '\n', &pairs);
+  for (size_t i = 0; i < pairs.size(); ++i) {
+    std::string key, value_str;
+    TrimWhitespaceASCII(pairs[i].first, TRIM_ALL, &key);
+    TrimWhitespaceASCII(pairs[i].second, TRIM_ALL, &value_str);
+    if (key == field) {
+      std::vector<std::string> split_value_str;
+      SplitString(value_str, ' ', &split_value_str);
+      if (split_value_str.size() != 2 || split_value_str[1] != "kB") {
+        NOTREACHED();
+        return 0;
+      }
+      size_t value;
+      if (!StringToSizeT(split_value_str[0], &value)) {
+        NOTREACHED();
+        return 0;
+      }
+      return value;
     }
   }
   NOTREACHED();
   return 0;
 }
 
 // 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) {
   // Use /proc/<pid>/task to find all threads and parse their /stat file.
@@ skipping 115 matching lines @@
 // 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 (!ReadFileToString(io_file, &proc_io_contents))
     return false;
 
-  (*io_counters).OtherOperationCount = 0;
-  (*io_counters).OtherTransferCount = 0;
+  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) {
-      case KEY_NAME:
-        last_key_name = tokenizer.token_piece();
-        state = KEY_VALUE;
-        break;
-      case KEY_VALUE:
-        DCHECK(!last_key_name.empty());
-        if (last_key_name == "syscr") {
-          StringToInt64(tokenizer.token_piece(),
-              reinterpret_cast<int64*>(&(*io_counters).ReadOperationCount));
-        } else if (last_key_name == "syscw") {
-          StringToInt64(tokenizer.token_piece(),
-              reinterpret_cast<int64*>(&(*io_counters).WriteOperationCount));
-        } else if (last_key_name == "rchar") {
-          StringToInt64(tokenizer.token_piece(),
-              reinterpret_cast<int64*>(&(*io_counters).ReadTransferCount));
-        } else if (last_key_name == "wchar") {
-          StringToInt64(tokenizer.token_piece(),
-              reinterpret_cast<int64*>(&(*io_counters).WriteTransferCount));
-        }
-        state = KEY_NAME;
-        break;
-    }
+  std::vector<std::pair<std::string, std::string> > pairs;
+  SplitStringIntoKeyValuePairs(proc_io_contents, ':', '\n', &pairs);
+  for (size_t i = 0; i < pairs.size(); ++i) {
+    std::string key, value_str;
+    TrimWhitespaceASCII(pairs[i].first, TRIM_ALL, &key);
+    TrimWhitespaceASCII(pairs[i].second, TRIM_ALL, &value_str);
+    uint64* target_counter = NULL;
+    if (key == "syscr")
+      target_counter = &io_counters->ReadOperationCount;
+    else if (key == "syscw")
+      target_counter = &io_counters->WriteOperationCount;
+    else if (key == "rchar")
+      target_counter = &io_counters->ReadTransferCount;
+    else if (key == "wchar")
+      target_counter = &io_counters->WriteTransferCount;
+    if (!target_counter)
+      continue;
+    bool converted = StringToUint64(value_str, target_counter);
+    DCHECK(converted);
   }
   return true;
 }
 
 ProcessMetrics::ProcessMetrics(ProcessHandle process)
     : process_(process),
       last_system_time_(0),
       last_cpu_(0) {
-  processor_count_ = base::SysInfo::NumberOfProcessors();
+  processor_count_ = SysInfo::NumberOfProcessors();
 }
 
 #if defined(OS_CHROMEOS)
 // Private, Shared and Proportional working set sizes are obtained from
 // /proc/<pid>/totmaps
 bool ProcessMetrics::GetWorkingSetKBytesTotmaps(WorkingSetKBytes *ws_usage)
   const {
   // The format of /proc/<pid>/totmaps is:
   //
   // Rss:                6120 kB
@@ skipping 198 matching lines @@
 
 #ifdef OS_CHROMEOS
   shmem = 0;
   slab = 0;
   gem_objects = -1;
   gem_size = -1;
 #endif
 }
 
 scoped_ptr<Value> SystemMemoryInfoKB::ToValue() const {
-  scoped_ptr<DictionaryValue> res(new base::DictionaryValue());
+  scoped_ptr<DictionaryValue> res(new DictionaryValue());
 
   res->SetInteger("total", total);
   res->SetInteger("free", free);
   res->SetInteger("buffers", buffers);
   res->SetInteger("cached", cached);
   res->SetInteger("active_anon", active_anon);
   res->SetInteger("inactive_anon", inactive_anon);
   res->SetInteger("active_file", active_file);
   res->SetInteger("inactive_file", inactive_file);
   res->SetInteger("swap_total", swap_total);
@@ skipping 31 matching lines @@
   meminfo->total = 0;
 
   std::vector<std::string> meminfo_lines;
   Tokenize(meminfo_data, "\n", &meminfo_lines);
   for (std::vector<std::string>::iterator it = meminfo_lines.begin();
        it != meminfo_lines.end(); ++it) {
     std::vector<std::string> tokens;
     SplitStringAlongWhitespace(*it, &tokens);
     // HugePages_* only has a number and no suffix so we can't rely on
     // there being exactly 3 tokens.
-    if (tokens.size() > 1) {
-      if (tokens[0] == "MemTotal:") {
-        StringToInt(tokens[1], &meminfo->total);
-        continue;
-      } if (tokens[0] == "MemFree:") {
-        StringToInt(tokens[1], &meminfo->free);
-        continue;
-      } if (tokens[0] == "Buffers:") {
-        StringToInt(tokens[1], &meminfo->buffers);
-        continue;
-      } if (tokens[0] == "Cached:") {
-        StringToInt(tokens[1], &meminfo->cached);
-        continue;
-      } if (tokens[0] == "Active(anon):") {
-        StringToInt(tokens[1], &meminfo->active_anon);
-        continue;
-      } if (tokens[0] == "Inactive(anon):") {
-        StringToInt(tokens[1], &meminfo->inactive_anon);
-        continue;
-      } if (tokens[0] == "Active(file):") {
-        StringToInt(tokens[1], &meminfo->active_file);
-        continue;
-      } if (tokens[0] == "Inactive(file):") {
-        StringToInt(tokens[1], &meminfo->inactive_file);
-        continue;
-      } if (tokens[0] == "SwapTotal:") {
-        StringToInt(tokens[1], &meminfo->swap_total);
-        continue;
-      } if (tokens[0] == "SwapFree:") {
-        StringToInt(tokens[1], &meminfo->swap_free);
-        continue;
-      } if (tokens[0] == "Dirty:") {
-        StringToInt(tokens[1], &meminfo->dirty);
-        continue;
-#if defined(OS_CHROMEOS)
-      // Chrome OS has a tweaked kernel that allows us to query Shmem, which is
-      // usually video memory otherwise invisible to the OS.
-      } if (tokens[0] == "Shmem:") {
-        StringToInt(tokens[1], &meminfo->shmem);
-        continue;
-      } if (tokens[0] == "Slab:") {
-        StringToInt(tokens[1], &meminfo->slab);
-        continue;
-#endif
-      }
-    } else
+    if (tokens.size() <= 1) {
       DLOG(WARNING) << "meminfo: tokens: " << tokens.size()
                     << " malformed line: " << *it;
+      continue;
+    }
+
+    int* target = NULL;
+    if (tokens[0] == "MemTotal:")
+      target = &meminfo->total;
+    else if (tokens[0] == "MemFree:")
+      target = &meminfo->free;
+    else if (tokens[0] == "Buffers:")
+      target = &meminfo->buffers;
+    else if (tokens[0] == "Cached:")
+      target = &meminfo->cached;
+    else if (tokens[0] == "Active(anon):")
+      target = &meminfo->active_anon;
+    else if (tokens[0] == "Inactive(anon):")
+      target = &meminfo->inactive_anon;
+    else if (tokens[0] == "Active(file):")
+      target = &meminfo->active_file;
+    else if (tokens[0] == "Inactive(file):")
+      target = &meminfo->inactive_file;
+    else if (tokens[0] == "SwapTotal:")
+      target = &meminfo->swap_total;
+    else if (tokens[0] == "SwapFree:")
+      target = &meminfo->swap_free;
+    else if (tokens[0] == "Dirty:")
+      target = &meminfo->dirty;
+#if defined(OS_CHROMEOS)
+    // Chrome OS has a tweaked kernel that allows us to query Shmem, which is
+    // usually video memory otherwise invisible to the OS.
+    else if (tokens[0] == "Shmem:")
+      target = &meminfo->shmem;
+    else if (tokens[0] == "Slab:")
+      target = &meminfo->slab;
+#endif
+    if (target)
+      StringToInt(tokens[1], target);
   }
 
   // Make sure we got a valid MemTotal.
-  if (!meminfo->total)
-    return false;
-
-  return true;
+  return meminfo->total > 0;
 }
 
 // exposed for testing
 bool ParseProcVmstat(const std::string& vmstat_data,
                      SystemMemoryInfoKB* meminfo) {
   // The format of /proc/vmstat is:
   //
   // nr_free_pages 299878
   // nr_inactive_anon 239863
   // nr_active_anon 1318966
   // nr_inactive_file 2015629
   // ...
   //
   // We iterate through the whole file because the position of the
   // fields are dependent on the kernel version and configuration.
 
   std::vector<std::string> vmstat_lines;
   Tokenize(vmstat_data, "\n", &vmstat_lines);
   for (std::vector<std::string>::iterator it = vmstat_lines.begin();
        it != vmstat_lines.end(); ++it) {
     std::vector<std::string> tokens;
     SplitString(*it, ' ', &tokens);
-    if (tokens.size() == 2) {
-      if (tokens[0] == "pswpin") {
-        StringToInt(tokens[1], &meminfo->pswpin);
-        continue;
-      } if (tokens[0] == "pswpout") {
-        StringToInt(tokens[1], &meminfo->pswpout);
-        continue;
-      } if (tokens[0] == "pgmajfault")
-        StringToInt(tokens[1], &meminfo->pgmajfault);
+    if (tokens.size() != 2)
+      continue;
+
+    if (tokens[0] == "pswpin") {
+      StringToInt(tokens[1], &meminfo->pswpin);
+    } else if (tokens[0] == "pswpout") {
+      StringToInt(tokens[1], &meminfo->pswpout);
+    } else if (tokens[0] == "pgmajfault") {
+      StringToInt(tokens[1], &meminfo->pgmajfault);
     }
   }
 
   return true;
 }
 
 bool GetSystemMemoryInfo(SystemMemoryInfoKB* meminfo) {
-  // Synchronously reading files in /proc is safe.
+  // Synchronously reading files in /proc and /sys are safe.
   ThreadRestrictions::ScopedAllowIO allow_io;
 
   // Used memory is: total - free - buffers - caches
   FilePath meminfo_file("/proc/meminfo");
   std::string meminfo_data;
   if (!ReadFileToString(meminfo_file, &meminfo_data)) {
     DLOG(WARNING) << "Failed to open " << meminfo_file.value();
     return false;
   }
 
@@ skipping 61 matching lines @@
   writes = 0;
   writes_merged = 0;
   sectors_written = 0;
   write_time = 0;
   io = 0;
   io_time = 0;
   weighted_io_time = 0;
 }
 
 scoped_ptr<Value> SystemDiskInfo::ToValue() const {
-  scoped_ptr<DictionaryValue> res(new base::DictionaryValue());
+  scoped_ptr<DictionaryValue> res(new DictionaryValue());
 
   // Write out uint64 variables as doubles.
   // Note: this may discard some precision, but for JS there's no other option.
   res->SetDouble("reads", static_cast<double>(reads));
   res->SetDouble("reads_merged", static_cast<double>(reads_merged));
   res->SetDouble("sectors_read", static_cast<double>(sectors_read));
   res->SetDouble("read_time", static_cast<double>(read_time));
   res->SetDouble("writes", static_cast<double>(writes));
   res->SetDouble("writes_merged", static_cast<double>(writes_merged));
   res->SetDouble("sectors_written", static_cast<double>(sectors_written));
   res->SetDouble("write_time", static_cast<double>(write_time));
   res->SetDouble("io", static_cast<double>(io));
   res->SetDouble("io_time", static_cast<double>(io_time));
   res->SetDouble("weighted_io_time", static_cast<double>(weighted_io_time));
 
   return res.PassAs<Value>();
 }
 
 bool IsValidDiskName(const std::string& candidate) {
   if (candidate.length() < 3)
     return false;
-  if (candidate.substr(0,2) == "sd" || candidate.substr(0,2) == "hd") {
-    // [sh]d[a-z]+ case
-    for (size_t i = 2; i < candidate.length(); i++) {
+  if (candidate[1] == 'd' &&
+      (candidate[0] == 'h' || candidate[0] == 's' || candidate[0] == 'v')) {
+    // [hsv]d[a-z]+ case

[Lei Zhang, 2014/09/06 09:31:58]

vd* are virtual disks

+    for (size_t i = 2; i < candidate.length(); ++i) {
       if (!islower(candidate[i]))
         return false;
     }
-  } else {
-    if (candidate.length() < 7) {
-      return false;
-    }
-    if (candidate.substr(0,6) == "mmcblk") {
-      // mmcblk[0-9]+ case
-      for (size_t i = 6; i < candidate.length(); i++) {
-        if (!isdigit(candidate[i]))
-          return false;
-      }
-    } else {
-      return false;
-    }
+    return true;
   }
 
+  const char kMMCName[] = "mmcblk";
+  const size_t kMMCNameLen = strlen(kMMCName);
+  if (candidate.length() < kMMCNameLen + 1)
+    return false;
+  if (candidate.compare(0, kMMCNameLen, kMMCName) != 0)
+    return false;
+
+  // mmcblk[0-9]+ case
+  for (size_t i = kMMCNameLen; i < candidate.length(); ++i) {
+    if (!isdigit(candidate[i]))
+      return false;
+  }
   return true;
 }
 
 bool GetSystemDiskInfo(SystemDiskInfo* diskinfo) {
   // Synchronously reading files in /proc is safe.
   ThreadRestrictions::ScopedAllowIO allow_io;
 
   FilePath diskinfo_file("/proc/diskstats");
   std::string diskinfo_data;
   if (!ReadFileToString(diskinfo_file, &diskinfo_data)) {
@@ skipping 84 matching lines @@
   else
     res->SetDouble("compression_ratio", 0);
 
   return res.PassAs<Value>();
 }
 
 void GetSwapInfo(SwapInfo* swap_info) {
   // Synchronously reading files in /sys/block/zram0 is safe.
   ThreadRestrictions::ScopedAllowIO allow_io;
 
-  base::FilePath zram_path("/sys/block/zram0");
+  FilePath zram_path("/sys/block/zram0");
   uint64 orig_data_size = ReadFileToUint64(zram_path.Append("orig_data_size"));
   if (orig_data_size <= 4096) {
     // A single page is compressed at startup, and has a high compression
     // ratio. We ignore this as it doesn't indicate any real swapping.
     swap_info->orig_data_size = 0;
     swap_info->num_reads = 0;
     swap_info->num_writes = 0;
     swap_info->compr_data_size = 0;
     swap_info->mem_used_total = 0;
     return;
   }
   swap_info->orig_data_size = orig_data_size;
   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