Replace some Tokenize calls with SplitString.

chrome/browser/devtools/device/android_device_info_query.cc

 // Copyright 2014 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/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/devtools/device/android_device_manager.h"
 
@@ skipping 106 matching lines @@
 
 using StringMap = std::map<std::string, std::string>;
 
 void MapProcessesToPackages(const std::string& response,
                             StringMap* pid_to_package,
                             StringMap* pid_to_user) {
   // Parse 'ps' output which on Android looks like this:
   //
   // USER PID PPID VSIZE RSS WCHAN PC ? NAME
   //
-  std::vector<std::string> entries;
-  Tokenize(response, "\n", &entries);
-  for (size_t i = 1; i < entries.size(); ++i) {
-    std::vector<std::string> fields;
-    Tokenize(entries[i], " \r", &fields);
+  for (const base::StringPiece& line :
+       base::SplitStringPiece(response, "\n", base::KEEP_WHITESPACE,
+                              base::SPLIT_WANT_NONEMPTY)) {
+    std::vector<std::string> fields =
+        base::SplitString(line, " \r", base::KEEP_WHITESPACE,
+                          base::SPLIT_WANT_NONEMPTY);
     if (fields.size() < 9)
       continue;
     std::string pid = fields[1];
     (*pid_to_package)[pid] = fields[8];
     (*pid_to_user)[pid] = fields[0];
   }
 }
 
 StringMap MapSocketsToProcesses(const std::string& response) {
   // Parse 'cat /proc/net/unix' output which on Android looks like this:
   //
   // Num       RefCount Protocol Flags    Type St Inode Path
   // 00000000: 00000002 00000000 00010000 0001 01 331813 /dev/socket/zygote
   // 00000000: 00000002 00000000 00010000 0001 01 358606 @xxx_devtools_remote
   // 00000000: 00000002 00000000 00010000 0001 01 347300 @yyy_devtools_remote
   //
   // We need to find records with paths starting from '@' (abstract socket)
   // and containing the channel pattern ("_devtools_remote").
   StringMap socket_to_pid;
-  std::vector<std::string> entries;
-  Tokenize(response, "\n", &entries);
-  for (size_t i = 1; i < entries.size(); ++i) {
-    std::vector<std::string> fields;
-    Tokenize(entries[i], " \r", &fields);
+  for (const base::StringPiece& line :
+       base::SplitStringPiece(response, "\n", base::KEEP_WHITESPACE,
+                              base::SPLIT_WANT_NONEMPTY)) {
+    std::vector<std::string> fields =
+        base::SplitString(line, " \r", base::KEEP_WHITESPACE,
+                          base::SPLIT_WANT_NONEMPTY);
     if (fields.size() < 8)
       continue;
     if (fields[3] != "00010000" || fields[5] != "01")
       continue;
     std::string path_field = fields[7];
     if (path_field.size() < 1 || path_field[0] != '@')
       continue;
     size_t socket_name_pos = path_field.find(kDevToolsSocketSuffix);
     if (socket_name_pos == std::string::npos)
       continue;
 
     std::string socket = path_field.substr(1);
 
     std::string pid;
     size_t socket_name_end = socket_name_pos + strlen(kDevToolsSocketSuffix);
     if (socket_name_end < path_field.size() &&
         path_field[socket_name_end] == '_') {
       pid = path_field.substr(socket_name_end + 1);
     }
     socket_to_pid[socket] = pid;
   }
   return socket_to_pid;
 }
 
-gfx::Size ParseScreenSize(const std::string& str) {
-  std::vector<std::string> pairs;
-  Tokenize(str, "-", &pairs);
+gfx::Size ParseScreenSize(base::StringPiece str) {
+  std::vector<base::StringPiece> pairs =
+      base::SplitStringPiece(str, "-", base::KEEP_WHITESPACE,
+                             base::SPLIT_WANT_NONEMPTY);
   if (pairs.size() != 2)
     return gfx::Size();
 
   int width;
   int height;
-  std::vector<std::string> numbers;
-  Tokenize(pairs[1].substr(1, pairs[1].size() - 2), ",", &numbers);
+  std::vector<base::StringPiece> numbers =
+      base::SplitStringPiece(pairs[1].substr(1, pairs[1].size() - 2), ",",
+                             base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
   if (numbers.size() != 2 ||
       !base::StringToInt(numbers[0], &width) ||
       !base::StringToInt(numbers[1], &height))
     return gfx::Size();
 
   return gfx::Size(width, height);
 }
 
 gfx::Size ParseWindowPolicyResponse(const std::string& response) {
-  std::vector<std::string> lines;
-  Tokenize(response, "\r", &lines);
-  for (const std::string& line : lines) {
+  for (const base::StringPiece& line :
+      base::SplitStringPiece(response, "\r", base::KEEP_WHITESPACE,
+                             base::SPLIT_WANT_NONEMPTY)) {
     size_t pos = line.find(kScreenSizePrefix);
-    if (pos != std::string::npos) {
+    if (pos != base::StringPiece::npos) {
       return ParseScreenSize(
           line.substr(pos + strlen(kScreenSizePrefix)));
     }
   }
   return gfx::Size();
 }
 
 StringMap MapIdsToUsers(const std::string& response) {
   // Parse 'dumpsys user' output which looks like this:
   // Users:
   //   UserInfo{0:Test User:13} serialNo=0
   //     Created: <unknown>
   //     Last logged in: +17m18s871ms ago
   //   UserInfo{10:User with : (colon):10} serialNo=10
   //     Created: +3d4h35m1s139ms ago
   //     Last logged in: +17m26s287ms ago
   StringMap id_to_username;
-  std::vector<std::string> lines;
-  Tokenize(response, "\r", &lines);
-  for (const std::string& line : lines) {
+  for (const base::StringPiece& line :
+       base::SplitStringPiece(response, "\r", base::KEEP_WHITESPACE,
+                              base::SPLIT_WANT_NONEMPTY)) {
     size_t pos = line.find(kUserInfoPrefix);
     if (pos != std::string::npos) {
-      std::string fields = line.substr(pos + strlen(kUserInfoPrefix));
+      base::StringPiece fields = line.substr(pos + strlen(kUserInfoPrefix));
       size_t first_pos = fields.find_first_of(":");
       size_t last_pos = fields.find_last_of(":");
       if (first_pos != std::string::npos && last_pos != std::string::npos) {
-        std::string id = fields.substr(0, first_pos);
+        std::string id = fields.substr(0, first_pos).as_string();
         std::string name = fields.substr(first_pos + 1,
-                                         last_pos - first_pos - 1);
+                                         last_pos - first_pos - 1).as_string();
         id_to_username[id] = name;
       }
     }
   }
   return id_to_username;
 }
 
 std::string GetUserName(const std::string& unix_user,
                         const StringMap id_to_username) {
   // Parse username as returned by ps which looks like 'u0_a31'
@@ skipping 107 matching lines @@
 }
 
 // static
 void AndroidDeviceManager::QueryDeviceInfo(
     const RunCommandCallback& command_callback,
     const DeviceInfoCallback& callback) {
   command_callback.Run(
       kAllCommands,
       base::Bind(&ReceivedResponse, callback));
 }