Update SplitString calls in chrome.

chrome/tools/convert_dict/aff_reader.cc

 // Copyright (c) 2010 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 "chrome/tools/convert_dict/aff_reader.h"
 
 #include <algorithm>
 
 #include "base/files/file_util.h"
 #include "base/i18n/icu_string_conversions.h"
@@ skipping 211 matching lines @@
         }
         part = rule->substr(part_start);  // From here to end.
 
         if (part.find('-') != std::string::npos) {
           // This rule has a morph rule used by old Hungarian dictionaries.
           // When a line has a morph rule, its format becomes as listed below.
           //   AFX D   0 d e - M
           // To make hunspell work more happily, replace this morph rule with
           // a compound flag as listed below.
           //   AFX D   0 d/M e
-          std::vector<std::string> tokens;
-          base::SplitString(part, ' ', &tokens);
+          std::vector<std::string> tokens = base::SplitString(
+              part, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
           if (tokens.size() >= 5) {
             part = base::StringPrintf("%s %s/%s %s",
                                       tokens[0].c_str(),
                                       tokens[1].c_str(),
                                       tokens[4].c_str(),
                                       tokens[2].c_str());
           }
         }
 
         size_t slash_index = part.find('/');
         if (slash_index != std::string::npos && !has_indexed_affixes()) {
           // This can also have a rule string associated with it following a
           // slash. For example:
           //    PFX P   0 foo/Y  .
           // The "Y" is a flag. For example, the aff file might have a line:
           //    COMPOUNDFLAG Y
           // so that means that this prefix would be a compound one.
           //
           // It expects these rules to use the same alias rules as the .dic
           // file. We've forced it to use aliases, which is a numerical index
           // instead of these character flags, and this needs to be consistent.
 
           std::string before_flags = part.substr(0, slash_index + 1);
 
           // After the slash are both the flags, then whitespace, then the part
           // that tells us what to strip.
-          std::vector<std::string> after_slash;
-          base::SplitString(part.substr(slash_index + 1), ' ', &after_slash);
+          std::vector<std::string> after_slash = base::SplitString(
+              part.substr(slash_index + 1), " ",
+              base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
           if (after_slash.size() == 0) {
             Panic("Found 0 terms after slash in affix rule '%s', "
                       "but need at least 2.",
                    part.c_str());
           }
           if (after_slash.size() == 1) {
             printf("WARNING: Found 1 term after slash in affix rule '%s', "
                       "but expected at least 2. Adding '.'.\n",
                    part.c_str());
             after_slash.push_back(".");
@@ skipping 55 matching lines @@
 }
 
 void AffReader::HandleEncodedCommand(const std::string& line) {
   std::string utf8;
   if (!EncodingToUTF8(line, &utf8))
     Panic("Cannot encode command '%s' to utf8.", line.c_str());
   other_commands_.push_back(utf8);
 }
 
 }  // namespace convert_dict