iwyu: Include stringprintf.h where appropriate, part 2.

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"
+#include "base/stringprintf.h"
 #include "base/string_split.h"
-#include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/tools/convert_dict/hunspell_reader.h"
 
 namespace convert_dict {
 
 namespace {
 
 // Returns true if the given line begins with the given case-sensitive
 // NULL-terminated ASCII string.
 bool StringBeginsWith(const std::string& str, const char* with) {
@@ skipping 193 matching lines @@
         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);
           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());
+            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
@@ skipping 10 matching lines @@
           std::vector<std::string> 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]),
-                  after_slash[1].c_str());
+          part = base::StringPrintf("%s%d %s",
+                                    before_flags.c_str(),
+                                    GetAFIndexForAFString(after_slash[0]),
+                                    after_slash[1].c_str());
         }
 
         // Reencode from here
         std::string reencoded;
         if (!EncodingToUTF8(part, &reencoded))
           break;
 
         *rule = rule->substr(0, part_start) + reencoded;
         break;
       }
@@ skipping 32 matching lines @@
   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