Update //base to chromium 9659b08ea5a34f889dc4166217f438095ddc10d2

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 545 matching lines @@
   // Buffers:        429596 kB
   // Cached:        4728232 kB
   // ...
   // There is no guarantee on the ordering or position
   // though it doesn't appear to change very often
 
   // As a basic sanity check, let's make sure we at least get non-zero
   // MemTotal value
   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);
+  for (const StringPiece& line : SplitStringPiece(
+           meminfo_data, "\n", KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY)) {
+    std::vector<StringPiece> tokens = SplitStringPiece(
+        line, kWhitespaceASCII, TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
     // HugePages_* only has a number and no suffix so we can't rely on
     // there being exactly 3 tokens.
     if (tokens.size() <= 1) {
       DLOG(WARNING) << "meminfo: tokens: " << tokens.size()
-                    << " malformed line: " << *it;
+                    << " malformed line: " << line.as_string();
       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;
@@ skipping 36 matching lines @@
   //
   // 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);
+  for (const StringPiece& line : SplitStringPiece(
+           vmstat_data, "\n", KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY)) {
+    std::vector<StringPiece> tokens =
+        SplitStringPiece(line, " ", KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY);
     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);
     }
@@ skipping 136 matching lines @@
   // Synchronously reading files in /proc does not hit the disk.
   ThreadRestrictions::ScopedAllowIO allow_io;
 
   FilePath diskinfo_file("/proc/diskstats");
   std::string diskinfo_data;
   if (!ReadFileToString(diskinfo_file, &diskinfo_data)) {
     DLOG(WARNING) << "Failed to open " << diskinfo_file.value();
     return false;
   }
 
-  std::vector<std::string> diskinfo_lines;
-  size_t line_count = Tokenize(diskinfo_data, "\n", &diskinfo_lines);
-  if (line_count == 0) {
+  std::vector<StringPiece> diskinfo_lines = SplitStringPiece(
+      diskinfo_data, "\n", KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY);
+  if (diskinfo_lines.size() == 0) {
     DLOG(WARNING) << "No lines found";
     return false;
   }
 
   diskinfo->reads = 0;
   diskinfo->reads_merged = 0;
   diskinfo->sectors_read = 0;
   diskinfo->read_time = 0;
   diskinfo->writes = 0;
   diskinfo->writes_merged = 0;
   diskinfo->sectors_written = 0;
   diskinfo->write_time = 0;
   diskinfo->io = 0;
   diskinfo->io_time = 0;
   diskinfo->weighted_io_time = 0;
 
   uint64 reads = 0;
   uint64 reads_merged = 0;
   uint64 sectors_read = 0;
   uint64 read_time = 0;
   uint64 writes = 0;
   uint64 writes_merged = 0;
   uint64 sectors_written = 0;
   uint64 write_time = 0;
   uint64 io = 0;
   uint64 io_time = 0;
   uint64 weighted_io_time = 0;
 
-  for (size_t i = 0; i < line_count; i++) {
-    std::vector<std::string> disk_fields;
-    SplitStringAlongWhitespace(diskinfo_lines[i], &disk_fields);
+  for (const StringPiece& line : diskinfo_lines) {
+    std::vector<StringPiece> disk_fields = SplitStringPiece(
+        line, kWhitespaceASCII, TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
 
     // Fields may have overflowed and reset to zero.
-    if (IsValidDiskName(disk_fields[kDiskDriveName])) {
+    if (IsValidDiskName(disk_fields[kDiskDriveName].as_string())) {
       StringToUint64(disk_fields[kDiskReads], &reads);
       StringToUint64(disk_fields[kDiskReadsMerged], &reads_merged);
       StringToUint64(disk_fields[kDiskSectorsRead], &sectors_read);
       StringToUint64(disk_fields[kDiskReadTime], &read_time);
       StringToUint64(disk_fields[kDiskWrites], &writes);
       StringToUint64(disk_fields[kDiskWritesMerged], &writes_merged);
       StringToUint64(disk_fields[kDiskSectorsWritten], &sectors_written);
       StringToUint64(disk_fields[kDiskWriteTime], &write_time);
       StringToUint64(disk_fields[kDiskIO], &io);
       StringToUint64(disk_fields[kDiskIOTime], &io_time);
@@ skipping 65 matching lines @@
 #if defined(OS_LINUX)
 int ProcessMetrics::GetIdleWakeupsPerSecond() {
   uint64 wake_ups;
   const char kWakeupStat[] = "se.statistics.nr_wakeups";
   return ReadProcSchedAndGetFieldAsUint64(process_, kWakeupStat, &wake_ups) ?
       CalculateIdleWakeupsPerSecond(wake_ups) : 0;
 }
 #endif  // defined(OS_LINUX)
 
 }  // namespace base