Move more string_util functions to base namespace.

base/strings/string_util.cc

 // Copyright 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 "base/strings/string_util.h"
 
 #include <ctype.h>
 #include <errno.h>
 #include <math.h>
 #include <stdarg.h>
@@ skipping 316 matching lines @@
   STR result;
   result.resize(text.size());
 
   // Set flags to pretend we're already in a trimmed whitespace sequence, so we
   // will trim any leading whitespace.
   bool in_whitespace = true;
   bool already_trimmed = true;
 
   int chars_written = 0;
   for (typename STR::const_iterator i(text.begin()); i != text.end(); ++i) {
-    if (IsWhitespace(*i)) {
+    if (IsUnicodeWhitespace(*i)) {
       if (!in_whitespace) {
         // Reduce all whitespace sequences to a single space.
         in_whitespace = true;
         result[chars_written++] = L' ';
       }
       if (trim_sequences_with_line_breaks && !already_trimmed &&
           ((*i == '\n') || (*i == '\r'))) {
         // Whitespace sequences containing CR or LF are eliminated entirely.
         already_trimmed = true;
         --chars_written;
@@ skipping 262 matching lines @@
     if (search.size() > str.size())
       return false;
     return std::equal(search.begin(), search.end(),
                       str.begin() + (str.size() - search.size()),
                       CaseInsensitiveCompare<char16>());
   }
   return EndsWith(StringPiece16(str), StringPiece16(search),
                     CompareCase::SENSITIVE);
 }
 
-}  // namespace base
+char HexDigitToInt(wchar_t c) {
+  DCHECK(IsHexDigit(c));
+  if (c >= '0' && c <= '9')
+    return static_cast<char>(c - '0');
+  if (c >= 'A' && c <= 'F')
+    return static_cast<char>(c - 'A' + 10);
+  if (c >= 'a' && c <= 'f')
+    return static_cast<char>(c - 'a' + 10);
+  return 0;
+}
 
 static const char* const kByteStringsUnlocalized[] = {
   " B",
   " kB",
   " MB",
   " GB",
   " TB",
   " PB"
 };
 
 string16 FormatBytesUnlocalized(int64 bytes) {
   double unit_amount = static_cast<double>(bytes);
   size_t dimension = 0;
   const int kKilo = 1024;
   while (unit_amount >= kKilo &&
          dimension < arraysize(kByteStringsUnlocalized) - 1) {
     unit_amount /= kKilo;
     dimension++;
   }
 
   char buf[64];
   if (bytes != 0 && dimension > 0 && unit_amount < 100) {
     base::snprintf(buf, arraysize(buf), "%.1lf%s", unit_amount,
                    kByteStringsUnlocalized[dimension]);
   } else {
     base::snprintf(buf, arraysize(buf), "%.0lf%s", unit_amount,
                    kByteStringsUnlocalized[dimension]);
   }
 
-  return base::ASCIIToUTF16(buf);
+  return ASCIIToUTF16(buf);
 }
 
+}  // namespace base
+
 // Runs in O(n) time in the length of |str|.
 template<class StringType>
 void DoReplaceSubstringsAfterOffset(StringType* str,
                                     size_t offset,
                                     const StringType& find_this,
                                     const StringType& replace_with,
                                     bool replace_all) {
   DCHECK(!find_this.empty());
 
   // If the find string doesn't appear, there's nothing to do.
@@ skipping 444 matching lines @@
 }
 
 }  // namespace
 
 size_t base::strlcpy(char* dst, const char* src, size_t dst_size) {
   return lcpyT<char>(dst, src, dst_size);
 }
 size_t base::wcslcpy(wchar_t* dst, const wchar_t* src, size_t dst_size) {
   return lcpyT<wchar_t>(dst, src, dst_size);
 }