Move the number conversions from string_util to a new file....

chrome/common/extensions/extension.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/common/extensions/extension.h"
 
 #include <algorithm>
 
 #include "app/l10n_util.h"
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/file_version_info.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/stl_util-inl.h"
 #include "base/third_party/nss/blapi.h"
 #include "base/third_party/nss/sha256.h"
+#include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/extension_action.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_l10n_util.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/extensions/user_script.h"
@@ skipping 23 matching lines @@
 const char kPublic[] = "PUBLIC";
 const char kPrivate[] = "PRIVATE";
 
 const int kRSAKeySize = 1024;
 
 // Converts a normal hexadecimal string into the alphabet used by extensions.
 // We use the characters 'a'-'p' instead of '0'-'f' to avoid ever having a
 // completely numeric host, since some software interprets that as an IP
 // address.
 static void ConvertHexadecimalToIDAlphabet(std::string* id) {
-  for (size_t i = 0; i < id->size(); ++i)
-    (*id)[i] = HexStringToInt(id->substr(i, 1)) + 'a';
+  for (size_t i = 0; i < id->size(); ++i) {
+    int val;
+    if (base::HexStringToInt(id->substr(i, 1), &val))
+      (*id)[i] = val + 'a';
+    else
+      (*id)[i] = 'a';
+  }
 }
 
 const int kValidWebExtentSchemes =
     URLPattern::SCHEME_HTTP | URLPattern::SCHEME_HTTPS;
 
 }  // namespace
 
 const FilePath::CharType Extension::kManifestFilename[] =
     FILE_PATH_LITERAL("manifest.json");
 const FilePath::CharType Extension::kLocaleFolder[] =
@@ skipping 138 matching lines @@
 // Helper method that loads a UserScript object from a dictionary in the
 // content_script list of the manifest.
 bool Extension::LoadUserScriptHelper(const DictionaryValue* content_script,
                                      int definition_index, std::string* error,
                                      UserScript* result) {
   // run_at
   if (content_script->HasKey(keys::kRunAt)) {
     std::string run_location;
     if (!content_script->GetString(keys::kRunAt, &run_location)) {
       *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidRunAt,
-          IntToString(definition_index));
+          base::IntToString(definition_index));
       return false;
     }
 
     if (run_location == values::kRunAtDocumentStart) {
       result->set_run_location(UserScript::DOCUMENT_START);
     } else if (run_location == values::kRunAtDocumentEnd) {
       result->set_run_location(UserScript::DOCUMENT_END);
     } else if (run_location == values::kRunAtDocumentIdle) {
       result->set_run_location(UserScript::DOCUMENT_IDLE);
     } else {
       *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidRunAt,
-          IntToString(definition_index));
+          base::IntToString(definition_index));
       return false;
     }
   }
 
   // all frames
   if (content_script->HasKey(keys::kAllFrames)) {
     bool all_frames = false;
     if (!content_script->GetBoolean(keys::kAllFrames, &all_frames)) {
       *error = ExtensionErrorUtils::FormatErrorMessage(
-            errors::kInvalidAllFrames, IntToString(definition_index));
+            errors::kInvalidAllFrames, base::IntToString(definition_index));
       return false;
     }
     result->set_match_all_frames(all_frames);
   }
 
   // matches
   ListValue* matches = NULL;
   if (!content_script->GetList(keys::kMatches, &matches)) {
     *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidMatches,
-        IntToString(definition_index));
+        base::IntToString(definition_index));
     return false;
   }
 
   if (matches->GetSize() == 0) {
     *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidMatchCount,
-        IntToString(definition_index));
+        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 = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidMatch,
-          IntToString(definition_index), IntToString(j));
+          base::IntToString(definition_index), base::IntToString(j));
       return false;
     }
 
     URLPattern pattern(UserScript::kValidUserScriptSchemes);
     if (!pattern.Parse(match_str)) {
       *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidMatch,
-          IntToString(definition_index), IntToString(j));
+          base::IntToString(definition_index), base::IntToString(j));
       return false;
     }
 
     result->add_url_pattern(pattern);
   }
 
   // include/exclude globs (mostly for Greasemonkey compatibility)
   if (!LoadGlobsHelper(content_script, definition_index, keys::kIncludeGlobs,
                        error, &UserScript::add_glob, result)) {
       return false;
   }
 
   if (!LoadGlobsHelper(content_script, definition_index, keys::kExcludeGlobs,
                        error, &UserScript::add_exclude_glob, result)) {
       return false;
   }
 
   // js and css keys
   ListValue* js = NULL;
   if (content_script->HasKey(keys::kJs) &&
       !content_script->GetList(keys::kJs, &js)) {
     *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidJsList,
-        IntToString(definition_index));
+        base::IntToString(definition_index));
     return false;
   }
 
   ListValue* css = NULL;
   if (content_script->HasKey(keys::kCss) &&
       !content_script->GetList(keys::kCss, &css)) {
     *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidCssList,
-        IntToString(definition_index));
+        base::IntToString(definition_index));
     return false;
   }
 
   // The manifest needs to have at least one js or css user script definition.
   if (((js ? js->GetSize() : 0) + (css ? css->GetSize() : 0)) == 0) {
     *error = ExtensionErrorUtils::FormatErrorMessage(errors::kMissingFile,
-        IntToString(definition_index));
+        base::IntToString(definition_index));
     return false;
   }
 
   if (js) {
     for (size_t script_index = 0; script_index < js->GetSize();
          ++script_index) {
       Value* value;
       std::string relative;
       if (!js->Get(script_index, &value) || !value->GetAsString(&relative)) {
         *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidJs,
-            IntToString(definition_index), IntToString(script_index));
+            base::IntToString(definition_index),
+            base::IntToString(script_index));
         return false;
       }
       GURL url = GetResourceURL(relative);
       ExtensionResource resource = 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) {
       Value* value;
       std::string relative;
       if (!css->Get(script_index, &value) || !value->GetAsString(&relative)) {
         *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidCss,
-            IntToString(definition_index), IntToString(script_index));
+            base::IntToString(definition_index),
+            base::IntToString(script_index));
         return false;
       }
       GURL url = GetResourceURL(relative);
       ExtensionResource resource = GetResource(relative);
       result->css_scripts().push_back(UserScript::File(
           resource.extension_root(), resource.relative_path(), url));
     }
   }
 
   return true;
 }
 
 bool Extension::LoadGlobsHelper(
     const DictionaryValue* content_script,
     int content_script_index,
     const wchar_t* globs_property_name,
     std::string* error,
     void(UserScript::*add_method)(const std::string& glob),
     UserScript *instance) {
   if (!content_script->HasKey(globs_property_name))
     return true;  // they are optional
 
   ListValue* list = NULL;
   if (!content_script->GetList(globs_property_name, &list)) {
     *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidGlobList,
-        IntToString(content_script_index), WideToASCII(globs_property_name));
+        base::IntToString(content_script_index),
+        WideToUTF8(globs_property_name));
     return false;
   }
 
   for (size_t i = 0; i < list->GetSize(); ++i) {
     std::string glob;
     if (!list->GetString(i, &glob)) {
       *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidGlob,
-          IntToString(content_script_index), WideToASCII(globs_property_name),
-          IntToString(i));
+          base::IntToString(content_script_index),
+          WideToUTF8(globs_property_name),
+          base::IntToString(i));
       return false;
     }
 
     (instance->*add_method)(glob);
   }
 
   return true;
 }
 
 ExtensionAction* Extension::LoadExtensionActionHelper(
@@ skipping 163 matching lines @@
   if (temp->GetType() != Value::TYPE_LIST) {
     *error = list_error;
     return false;
   }
 
   ListValue* pattern_list = static_cast<ListValue*>(temp);
   for (size_t i = 0; i < pattern_list->GetSize(); ++i) {
     std::string pattern_string;
     if (!pattern_list->GetString(i, &pattern_string)) {
       *error = ExtensionErrorUtils::FormatErrorMessage(value_error,
-                                                       UintToString(i));
+                                                       base::UintToString(i));
       return false;
     }
 
     URLPattern pattern(kValidWebExtentSchemes);
     if (!pattern.Parse(pattern_string)) {
       *error = ExtensionErrorUtils::FormatErrorMessage(value_error,
-                                                       UintToString(i));
+                                                       base::UintToString(i));
       return false;
     }
 
     // We do not allow authors to put wildcards in their paths. Instead, we
     // imply one at the end.
     if (pattern.path().find('*') != std::string::npos) {
       *error = ExtensionErrorUtils::FormatErrorMessage(value_error,
-                                                       UintToString(i));
+                                                       base::UintToString(i));
       return false;
     }
     pattern.set_path(pattern.path() + '*');
 
     extent->AddPattern(pattern);
   }
 
   return true;
 }
 
@@ skipping 331 matching lines @@
   scoped_ptr<SkBitmap> decoded(new SkBitmap());
   *decoded = decoder.Decode(data, file_contents.length());
   if (decoded->empty()) {
     LOG(ERROR) << "Could not decode icon file: "
                << WideToUTF8(icon_path.ToWStringHack());
     return;
   }
 
   if (decoded->width() != icon_size || decoded->height() != icon_size) {
     LOG(ERROR) << "Icon file has unexpected size: "
-      << IntToString(decoded->width()) << "x"
-      << IntToString(decoded->height());
+               << base::IntToString(decoded->width()) << "x"
+               << base::IntToString(decoded->height());
     return;
   }
 
   result->swap(decoded);
 }
 
 GURL Extension::GetBaseURLFromExtensionId(const std::string& extension_id) {
   return GURL(std::string(chrome::kExtensionScheme) +
               chrome::kStandardSchemeSeparator + extension_id + "/");
 }
@@ skipping 127 matching lines @@
 
   // Initialize icons (if present).
   if (source.HasKey(keys::kIcons)) {
     DictionaryValue* icons_value = NULL;
     if (!source.GetDictionary(keys::kIcons, &icons_value)) {
       *error = errors::kInvalidIcons;
       return false;
     }
 
     for (size_t i = 0; i < arraysize(kIconSizes); ++i) {
-      std::wstring key = ASCIIToWide(IntToString(kIconSizes[i]));
+      std::wstring key = ASCIIToWide(base::IntToString(kIconSizes[i]));
       if (icons_value->HasKey(key)) {
         std::string icon_path;
         if (!icons_value->GetString(key, &icon_path)) {
           *error = ExtensionErrorUtils::FormatErrorMessage(
               errors::kInvalidIconPath, WideToASCII(key));
           return false;
         }
         icons_[kIconSizes[i]] = icon_path;
       }
     }
@@ skipping 104 matching lines @@
       bool is_public = false;
 
       if (!list_value->GetDictionary(i, &plugin_value)) {
         *error = errors::kInvalidPlugins;
         return false;
       }
 
       // Get plugins[i].path.
       if (!plugin_value->GetString(keys::kPluginsPath, &path)) {
         *error = ExtensionErrorUtils::FormatErrorMessage(
-            errors::kInvalidPluginsPath, IntToString(i));
+            errors::kInvalidPluginsPath, base::IntToString(i));
         return false;
       }
 
       // Get plugins[i].content (optional).
       if (plugin_value->HasKey(keys::kPluginsPublic)) {
         if (!plugin_value->GetBoolean(keys::kPluginsPublic, &is_public)) {
           *error = ExtensionErrorUtils::FormatErrorMessage(
-              errors::kInvalidPluginsPublic, IntToString(i));
+              errors::kInvalidPluginsPublic, base::IntToString(i));
           return false;
         }
       }
 
       plugins_.push_back(PluginInfo());
       plugins_.back().path = path_.AppendASCII(path);
       plugins_.back().is_public = is_public;
     }
   }
 
@@ skipping 32 matching lines @@
       ToolstripInfo toolstrip;
       DictionaryValue* toolstrip_value;
       std::string toolstrip_path;
       if (list_value->GetString(i, &toolstrip_path)) {
         // Support a simple URL value for backwards compatibility.
         toolstrip.toolstrip = GetResourceURL(toolstrip_path);
       } else if (list_value->GetDictionary(i, &toolstrip_value)) {
         if (!toolstrip_value->GetString(keys::kToolstripPath,
                                         &toolstrip_path)) {
           *error = ExtensionErrorUtils::FormatErrorMessage(
-              errors::kInvalidToolstrip, IntToString(i));
+              errors::kInvalidToolstrip, base::IntToString(i));
           return false;
         }
         toolstrip.toolstrip = GetResourceURL(toolstrip_path);
         if (toolstrip_value->HasKey(keys::kToolstripMolePath)) {
           std::string mole_path;
           if (!toolstrip_value->GetString(keys::kToolstripMolePath,
                                           &mole_path)) {
             *error = ExtensionErrorUtils::FormatErrorMessage(
-                errors::kInvalidToolstrip, IntToString(i));
+                errors::kInvalidToolstrip, base::IntToString(i));
             return false;
           }
           int height;
           if (!toolstrip_value->GetInteger(keys::kToolstripMoleHeight,
                                            &height) || (height < 0)) {
             *error = ExtensionErrorUtils::FormatErrorMessage(
-                errors::kInvalidToolstrip, IntToString(i));
+                errors::kInvalidToolstrip, base::IntToString(i));
             return false;
           }
           toolstrip.mole = GetResourceURL(mole_path);
           toolstrip.mole_height = height;
         }
       } else {
         *error = ExtensionErrorUtils::FormatErrorMessage(
-            errors::kInvalidToolstrip, IntToString(i));
+            errors::kInvalidToolstrip, base::IntToString(i));
         return false;
       }
       toolstrips_.push_back(toolstrip);
     }
   }
 
   // Initialize content scripts (optional).
   if (source.HasKey(keys::kContentScripts)) {
     ListValue* list_value;
     if (!source.GetList(keys::kContentScripts, &list_value)) {
       *error = errors::kInvalidContentScriptsList;
       return false;
     }
 
     for (size_t i = 0; i < list_value->GetSize(); ++i) {
       DictionaryValue* content_script;
       if (!list_value->GetDictionary(i, &content_script)) {
         *error = ExtensionErrorUtils::FormatErrorMessage(
-            errors::kInvalidContentScript, IntToString(i));
+            errors::kInvalidContentScript, base::IntToString(i));
         return false;
       }
 
       UserScript script;
       if (!LoadUserScriptHelper(content_script, i, error, &script))
         return false;  // Failed to parse script context definition
       script.set_extension_id(id());
       if (converted_from_user_script_) {
         script.set_emulate_greasemonkey(true);
         script.set_match_all_frames(true);  // greasemonkey matches all frames
@@ skipping 67 matching lines @@
     if (!source.GetList(keys::kPermissions, &permissions)) {
       *error = ExtensionErrorUtils::FormatErrorMessage(
           errors::kInvalidPermissions, "");
       return false;
     }
 
     for (size_t i = 0; i < permissions->GetSize(); ++i) {
       std::string permission_str;
       if (!permissions->GetString(i, &permission_str)) {
         *error = ExtensionErrorUtils::FormatErrorMessage(
-            errors::kInvalidPermission, IntToString(i));
+            errors::kInvalidPermission, base::IntToString(i));
         return false;
       }
 
       // Check if it's a module permission.  If so, enable that permission.
       if (IsAPIPermission(permission_str)) {
         api_permissions_.push_back(permission_str);
         continue;
       }
 
       // Otherwise, it's a host pattern permission.
       URLPattern pattern(URLPattern::SCHEME_HTTP |
                          URLPattern::SCHEME_HTTPS |
                          URLPattern::SCHEME_CHROMEUI);
       if (!pattern.Parse(permission_str)) {
         *error = ExtensionErrorUtils::FormatErrorMessage(
-            errors::kInvalidPermission, IntToString(i));
+            errors::kInvalidPermission, base::IntToString(i));
         return false;
       }
 
       if (!CanAccessURL(pattern)) {
         *error = ExtensionErrorUtils::FormatErrorMessage(
-            errors::kInvalidPermissionScheme, IntToString(i));
+            errors::kInvalidPermissionScheme, base::IntToString(i));
         return false;
       }
 
       // The path component is not used for host permissions, so we force it to
       // match all paths.
       pattern.set_path("/*");
 
       host_permissions_.push_back(pattern);
     }
   }
@@ skipping 145 matching lines @@
 void Extension::SetBackgroundPageReady() {
   DCHECK(!background_url().is_empty());
   background_page_ready_ = true;
   NotificationService::current()->Notify(
       NotificationType::EXTENSION_BACKGROUND_PAGE_READY,
       Source<Extension>(this),
       NotificationService::NoDetails());
 }
 
 static std::string SizeToString(const gfx::Size& max_size) {
-  return IntToString(max_size.width()) + "x" + IntToString(max_size.height());
+  return base::IntToString(max_size.width()) + "x" +
+         base::IntToString(max_size.height());
 }
 
 void Extension::SetCachedImage(const ExtensionResource& source,
                                const SkBitmap& image,
                                const gfx::Size& original_size) {
   DCHECK(source.extension_root() == path());  // The resource must come from
                                               // this extension.
   const FilePath& path = source.relative_path();
   gfx::Size actual_size(image.width(), image.height());
   if (actual_size == original_size) {
@@ skipping 136 matching lines @@
         } else {
           return false;
         }
       } else {
         return true;
       }
     }
   }
   return false;
 }