base: Move SplitString functions into the base namespace and update the callers.

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/file_util.h"
 #include "base/i18n/icu_string_conversions.h"
@@ skipping 203 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;
-          SplitString(part, ' ', &tokens);
+          base::SplitString(part, ' ', &tokens);
           if (tokens.size() >= 5) {
             part = 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 numberical 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;
-          SplitString(part.substr(slash_index + 1), ' ', &after_slash);
+          base::SplitString(part.substr(slash_index + 1), ' ', &after_slash);
           if (after_slash.size() < 2) {
             // Note that we may get a third term here which is the
             // morphological description of this rule. This happens in the tests
             // only, so we can just ignore it.
             printf("ERROR: Didn't get enough after the slash\n");
             return;
           }
 
           part = StringPrintf("%s%d %s", before_flags.c_str(),
                   GetAFIndexForAFString(after_slash[0]),
@@ skipping 18 matching lines @@
 }
 
 void AffReader::AddReplacement(std::string* rule) {
   TrimLine(rule);
 
   std::string utf8rule;
   if (!EncodingToUTF8(*rule, &utf8rule))
     return;
 
   std::vector<std::string> split;
-  SplitString(utf8rule, ' ', &split);
+  base::SplitString(utf8rule, ' ', &split);
 
   // There should be two parts.
   if (split.size() != 2)
     return;
 
   // Underscores are used to represent spaces
   // (since the line is parsed on spaces).
   std::replace(split[0].begin(), split[0].end(), '_', ' ');
   std::replace(split[1].begin(), split[1].end(), '_', ' ');
 
   replacements_.push_back(std::make_pair(split[0], split[1]));
 }
 
 void AffReader::HandleRawCommand(const std::string& line) {
   other_commands_.push_back(line);
 }
 
 void AffReader::HandleEncodedCommand(const std::string& line) {
   std::string utf8;
   if (EncodingToUTF8(line, &utf8))
     other_commands_.push_back(utf8);
 }
 
 }  // namespace convert_dict