Move RemoveChars, ReplaceChars, TrimString, and TruncateUTF8ToByteSize to base namespace.

base/strings/string_util.h

 // 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.
 //
 // This file defines utility functions for working with strings.
 
 #ifndef BASE_STRINGS_STRING_UTIL_H_
 #define BASE_STRINGS_STRING_UTIL_H_
 
 #include <ctype.h>
@@ skipping 130 matching lines @@
 
 // Contains the set of characters representing whitespace in the corresponding
 // encoding. Null-terminated.
 BASE_EXPORT extern const wchar_t kWhitespaceWide[];
 BASE_EXPORT extern const char16 kWhitespaceUTF16[];
 BASE_EXPORT extern const char kWhitespaceASCII[];
 
 // Null-terminated string representing the UTF-8 byte order mark.
 BASE_EXPORT extern const char kUtf8ByteOrderMark[];
 
-}  // namespace base
-
-#if defined(OS_WIN)
-#include "base/strings/string_util_win.h"
-#elif defined(OS_POSIX)
-#include "base/strings/string_util_posix.h"
-#else
-#error Define string operations appropriately for your platform
-#endif
-
 // Removes characters in |remove_chars| from anywhere in |input|.  Returns true
 // if any characters were removed.  |remove_chars| must be null-terminated.
 // NOTE: Safe to use the same variable for both |input| and |output|.
-BASE_EXPORT bool RemoveChars(const base::string16& input,
-                             const base::char16 remove_chars[],
-                             base::string16* output);
+BASE_EXPORT bool RemoveChars(const string16& input,
+                             const char16 remove_chars[],
+                             string16* output);
 BASE_EXPORT bool RemoveChars(const std::string& input,
                              const char remove_chars[],
                              std::string* output);
 
 // Replaces characters in |replace_chars| from anywhere in |input| with
 // |replace_with|.  Each character in |replace_chars| will be replaced with
 // the |replace_with| string.  Returns true if any characters were replaced.
 // |replace_chars| must be null-terminated.
 // NOTE: Safe to use the same variable for both |input| and |output|.
-BASE_EXPORT bool ReplaceChars(const base::string16& input,
-                              const base::char16 replace_chars[],
-                              const base::string16& replace_with,
-                              base::string16* output);
+BASE_EXPORT bool ReplaceChars(const string16& input,
+                              const char16 replace_chars[],
+                              const string16& replace_with,
+                              string16* output);
 BASE_EXPORT bool ReplaceChars(const std::string& input,
                               const char replace_chars[],
                               const std::string& replace_with,
                               std::string* output);
 
 // Removes characters in |trim_chars| from the beginning and end of |input|.
 // |trim_chars| must be null-terminated.
 // NOTE: Safe to use the same variable for both |input| and |output|.
-BASE_EXPORT bool TrimString(const base::string16& input,
-                            const base::char16 trim_chars[],
-                            base::string16* output);
+BASE_EXPORT bool TrimString(const string16& input,
+                            const char16 trim_chars[],
+                            string16* output);
 BASE_EXPORT bool TrimString(const std::string& input,
                             const char trim_chars[],
                             std::string* output);
 
 // Truncates a string to the nearest UTF-8 character that will leave
 // the string less than or equal to the specified byte size.
 BASE_EXPORT void TruncateUTF8ToByteSize(const std::string& input,
                                         const size_t byte_size,
                                         std::string* output);
 
+}  // namespace base
+
+#if defined(OS_WIN)
+#include "base/strings/string_util_win.h"
+#elif defined(OS_POSIX)
+#include "base/strings/string_util_posix.h"
+#else
+#error Define string operations appropriately for your platform
+#endif
+
 // Trims any whitespace from either end of the input string.  Returns where
 // whitespace was found.
 // The non-wide version has two functions:
 // * TrimWhitespaceASCII()
 //   This function is for ASCII strings and only looks for ASCII whitespace;
 // Please choose the best one according to your usage.
 // NOTE: Safe to use the same variable for both input and output.
 enum TrimPositions {
   TRIM_NONE     = 0,
   TRIM_LEADING  = 1 << 0,
@@ skipping 316 matching lines @@
 #elif defined(WCHAR_T_IS_UTF32)
   typedef uint32 Unsigned;
 #endif
 };
 template<>
 struct ToUnsigned<short> {
   typedef unsigned short Unsigned;
 };
 
 #endif  // BASE_STRINGS_STRING_UTIL_H_