Use correct IntToString variants in //chrome

chrome/common/extensions/manifest_handlers/content_scripts_handler.cc

 // Copyright (c) 2013 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/common/extensions/manifest_handlers/content_scripts_handler.h"
 
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 39 matching lines @@
         errors::kInvalidGlobList,
         base::IntToString(content_script_index),
         globs_property_name);
     return false;
   }
 
   for (size_t i = 0; i < list->GetSize(); ++i) {
     std::string glob;
     if (!list->GetString(i, &glob)) {
       *error = ErrorUtils::FormatErrorMessageUTF16(
-          errors::kInvalidGlob,
-          base::IntToString(content_script_index),
-          globs_property_name,
-          base::IntToString(i));
+          errors::kInvalidGlob, base::IntToString(content_script_index),
+          globs_property_name, base::SizeTToString(i));
       return false;
     }
 
     (instance->*add_method)(glob);
   }
 
   return true;
 }
 
 // Helper method that loads a UserScript object from a dictionary in the
@@ skipping 62 matching lines @@
   if (matches->GetSize() == 0) {
     *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidMatchCount,
         base::IntToString(definition_index));
     return false;
   }
   for (size_t j = 0; j < matches->GetSize(); ++j) {
     std::string match_str;
     if (!matches->GetString(j, &match_str)) {
       *error = ErrorUtils::FormatErrorMessageUTF16(
-          errors::kInvalidMatch,
-          base::IntToString(definition_index),
-          base::IntToString(j),
-          errors::kExpectString);
+          errors::kInvalidMatch, base::IntToString(definition_index),
+          base::SizeTToString(j), errors::kExpectString);
       return false;
     }
 
     URLPattern pattern(UserScript::ValidUserScriptSchemes(
         PermissionsData::CanExecuteScriptEverywhere(extension)));
 
     URLPattern::ParseResult parse_result = pattern.Parse(match_str);
     if (parse_result != URLPattern::PARSE_SUCCESS) {
       *error = ErrorUtils::FormatErrorMessageUTF16(
-          errors::kInvalidMatch,
-          base::IntToString(definition_index),
-          base::IntToString(j),
+          errors::kInvalidMatch, base::IntToString(definition_index),
+          base::SizeTToString(j),
           URLPattern::GetParseResultString(parse_result));
       return false;
     }
 
     // TODO(aboxhall): check for webstore
     if (!PermissionsData::CanExecuteScriptEverywhere(extension) &&
         pattern.scheme() != content::kChromeUIScheme) {
       // Exclude SCHEME_CHROMEUI unless it's been explicitly requested.
       // If the --extensions-on-chrome-urls flag has not been passed, requesting
       // a chrome:// url will cause a parse failure above, so there's no need to
@@ skipping 21 matching lines @@
       *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidExcludeMatches,
           base::IntToString(definition_index));
       return false;
     }
 
     for (size_t j = 0; j < exclude_matches->GetSize(); ++j) {
       std::string match_str;
       if (!exclude_matches->GetString(j, &match_str)) {
         *error = ErrorUtils::FormatErrorMessageUTF16(
-            errors::kInvalidExcludeMatch,
-            base::IntToString(definition_index),
-            base::IntToString(j),
-            errors::kExpectString);
+            errors::kInvalidExcludeMatch, base::IntToString(definition_index),
+            base::SizeTToString(j), errors::kExpectString);
         return false;
       }
 
       int valid_schemes = UserScript::ValidUserScriptSchemes(
           PermissionsData::CanExecuteScriptEverywhere(extension));
       URLPattern pattern(valid_schemes);
 
       URLPattern::ParseResult parse_result = pattern.Parse(match_str);
       if (parse_result != URLPattern::PARSE_SUCCESS) {
         *error = ErrorUtils::FormatErrorMessageUTF16(
-            errors::kInvalidExcludeMatch,
-            base::IntToString(definition_index), base::IntToString(j),
+            errors::kInvalidExcludeMatch, base::IntToString(definition_index),
+            base::SizeTToString(j),
             URLPattern::GetParseResultString(parse_result));
         return false;
       }
 
       result->add_exclude_url_pattern(pattern);
     }
   }
 
   // include/exclude globs (mostly for Greasemonkey compatibility)
   if (!LoadGlobsHelper(content_script, definition_index, keys::kIncludeGlobs,
@@ skipping 33 matching lines @@
     return false;
   }
 
   if (js) {
     for (size_t script_index = 0; script_index < js->GetSize();
          ++script_index) {
       const base::Value* value;
       std::string relative;
       if (!js->Get(script_index, &value) || !value->GetAsString(&relative)) {
         *error = ErrorUtils::FormatErrorMessageUTF16(
-            errors::kInvalidJs,
-            base::IntToString(definition_index),
-            base::IntToString(script_index));
+            errors::kInvalidJs, base::IntToString(definition_index),
+            base::SizeTToString(script_index));
         return false;
       }
       GURL url = extension->GetResourceURL(relative);
       ExtensionResource resource = extension->GetResource(relative);
       result->js_scripts().push_back(UserScript::File(
           resource.extension_root(), resource.relative_path(), url));
     }
   }
 
   if (css) {
     for (size_t script_index = 0; script_index < css->GetSize();
          ++script_index) {
       const base::Value* value;
       std::string relative;
       if (!css->Get(script_index, &value) || !value->GetAsString(&relative)) {
         *error = ErrorUtils::FormatErrorMessageUTF16(
-            errors::kInvalidCss,
-            base::IntToString(definition_index),
-            base::IntToString(script_index));
+            errors::kInvalidCss, base::IntToString(definition_index),
+            base::SizeTToString(script_index));
         return false;
       }
       GURL url = extension->GetResourceURL(relative);
       ExtensionResource resource = extension->GetResource(relative);
       result->css_scripts().push_back(UserScript::File(
           resource.extension_root(), resource.relative_path(), url));
     }
   }
 
   return true;
@@ skipping 95 matching lines @@
   const base::ListValue* scripts_list = NULL;
   if (!extension->manifest()->GetList(keys::kContentScripts, &scripts_list)) {
     *error = base::ASCIIToUTF16(errors::kInvalidContentScriptsList);
     return false;
   }
 
   for (size_t i = 0; i < scripts_list->GetSize(); ++i) {
     const base::DictionaryValue* script_dict = NULL;
     if (!scripts_list->GetDictionary(i, &script_dict)) {
       *error = ErrorUtils::FormatErrorMessageUTF16(
-          errors::kInvalidContentScript,
-          base::IntToString(i));
+          errors::kInvalidContentScript, base::SizeTToString(i));
       return false;
     }
 
     UserScript user_script;
     if (!LoadUserScriptFromDictionary(script_dict,
                                       i,
                                       extension,
                                       error,
                                       &user_script)) {
       return false;  // Failed to parse script context definition.
@@ skipping 52 matching lines @@
       if (!IsScriptValid(path, css_script.relative_path(),
                          IDS_EXTENSION_LOAD_CSS_FAILED, error))
         return false;
     }
   }
 
   return true;
 }
 
 }  // namespace extensions