Remove remaining legacy SplitString calls.

tools/ipc_fuzzer/message_tools/message_util.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 <limits.h>
 #include <stdlib.h>
 #include <iostream>
 #include <string>
 #include <vector>
 
@@ skipping 90 matching lines @@
     if (temp > 0)
       end_index = static_cast<size_t>(temp);
   }
 
   bool has_regexp = cmd->HasSwitch(kRegexpSwitch);
   RE2 filter_pattern(cmd->GetSwitchValueASCII(kRegexpSwitch));
 
   bool invert = cmd->HasSwitch(kInvertSwitch);
   bool perform_dump = cmd->HasSwitch(kDumpSwitch);
 
-  std::vector<base::FilePath::StringType> input_file_names;
   base::FilePath::StringType output_file_name;
-  base::SplitString(args[0], ',', &input_file_names);
 
   if (!perform_dump) {
     if (args.size() < 2) {
       usage();
       return EXIT_FAILURE;
     }
     output_file_name = args[1];
   }
 
   ipc_fuzzer::MessageVector input_message_vector;
-  for (std::vector<base::FilePath::StringType>::iterator
-      it = input_file_names.begin(); it != input_file_names.end(); ++it) {
+  for (const base::FilePath::StringType& name : base::SplitString(
+           args[0], base::FilePath::StringType(1, ','),
+           base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
     ipc_fuzzer::MessageVector message_vector;
-    if (!ipc_fuzzer::MessageFile::Read(base::FilePath(*it), &message_vector))
+    if (!ipc_fuzzer::MessageFile::Read(base::FilePath(name), &message_vector))
       return EXIT_FAILURE;
     input_message_vector.insert(input_message_vector.end(),
                                 message_vector.begin(), message_vector.end());
     message_vector.weak_clear();
   }
 
   bool has_indices = cmd->HasSwitch(kInSwitch);
   std::vector<bool> indices;
 
   if (has_indices) {
     indices.resize(input_message_vector.size(), false);
-    std::vector<std::string> index_strings;
-    base::SplitString(cmd->GetSwitchValueASCII(kInSwitch), ',', &index_strings);
-    for (std::vector<std::string>::iterator it = index_strings.begin();
-         it != index_strings.end(); ++it) {
-      int index = atoi(it->c_str());
+    for (const std::string& cur : base::SplitString(
+             cmd->GetSwitchValueASCII(kInSwitch), ",", base::TRIM_WHITESPACE,
+             base::SPLIT_WANT_ALL)) {
+      int index = atoi(cur.c_str());
       if (index >= 0 && static_cast<size_t>(index) < indices.size())
         indices[index] = true;
     }
   }
 
   ipc_fuzzer::MessageVector output_message_vector;
   std::vector<size_t> remap_vector;
 
   for (size_t i = 0; i < input_message_vector.size(); ++i) {
     bool valid = (i >= start_index && i < end_index);
@@ skipping 17 matching lines @@
     }
   } else {
     if (!ipc_fuzzer::MessageFile::Write(
             base::FilePath(output_file_name), output_message_vector)) {
       return EXIT_FAILURE;
     }
   }
 
   return EXIT_SUCCESS;
 }