Re-attempt r28993...

base/string_util.cc

 // Copyright (c) 2006-2008 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/string_util.h"
 
 #include "build/build_config.h"
 
 #include <ctype.h>
 #include <errno.h>
@@ skipping 326 matching lines @@
 }
 
 const std::wstring& EmptyWString() {
   return Singleton<EmptyStrings>::get()->ws;
 }
 
 const string16& EmptyString16() {
   return Singleton<EmptyStrings>::get()->s16;
 }
 
+#define WHITESPACE_UNICODE \
+  0x0009, /* <control-0009> to <control-000D> */ \
+  0x000A,                                        \
+  0x000B,                                        \
+  0x000C,                                        \
+  0x000D,                                        \
+  0x0020, /* Space */                            \
+  0x0085, /* <control-0085> */                   \
+  0x00A0, /* No-Break Space */                   \
+  0x1680, /* Ogham Space Mark */                 \
+  0x180E, /* Mongolian Vowel Separator */        \
+  0x2000, /* En Quad to Hair Space */            \
+  0x2001,                                        \
+  0x2002,                                        \
+  0x2003,                                        \
+  0x2004,                                        \
+  0x2005,                                        \
+  0x2006,                                        \
+  0x2007,                                        \
+  0x2008,                                        \
+  0x2009,                                        \
+  0x200A,                                        \
+  0x200C, /* Zero Width Non-Joiner */            \
+  0x2028, /* Line Separator */                   \
+  0x2029, /* Paragraph Separator */              \
+  0x202F, /* Narrow No-Break Space */            \
+  0x205F, /* Medium Mathematical Space */        \
+  0x3000, /* Ideographic Space */                \
+  0
+
 const wchar_t kWhitespaceWide[] = {
-  0x0009,  // <control-0009> to <control-000D>
-  0x000A,
-  0x000B,
-  0x000C,
-  0x000D,
-  0x0020,  // Space
-  0x0085,  // <control-0085>
-  0x00A0,  // No-Break Space
-  0x1680,  // Ogham Space Mark
-  0x180E,  // Mongolian Vowel Separator
-  0x2000,  // En Quad to Hair Space
-  0x2001,
-  0x2002,
-  0x2003,
-  0x2004,
-  0x2005,
-  0x2006,
-  0x2007,
-  0x2008,
-  0x2009,
-  0x200A,
-  0x200C,  // Zero Width Non-Joiner
-  0x2028,  // Line Separator
-  0x2029,  // Paragraph Separator
-  0x202F,  // Narrow No-Break Space
-  0x205F,  // Medium Mathematical Space
-  0x3000,  // Ideographic Space
-  0
+  WHITESPACE_UNICODE
+};
+const char16 kWhitespaceUTF16[] = {
+  WHITESPACE_UNICODE
 };
 const char kWhitespaceASCII[] = {
   0x09,    // <control-0009> to <control-000D>
   0x0A,
   0x0B,
   0x0C,
   0x0D,
   0x20,    // Space
   0
 };
@@ skipping 29 matching lines @@
       ((first_good_char == 0) ? TRIM_NONE : TRIM_LEADING) |
       ((last_good_char == last_char) ? TRIM_NONE : TRIM_TRAILING));
 }
 
 bool TrimString(const std::wstring& input,
                 const wchar_t trim_chars[],
                 std::wstring* output) {
   return TrimStringT(input, trim_chars, TRIM_ALL, output) != TRIM_NONE;
 }
 
+#if !defined(WCHAR_T_IS_UTF16)
+bool TrimString(const string16& input,
+                const char16 trim_chars[],
+                string16* output) {
+  return TrimStringT(input, trim_chars, TRIM_ALL, output) != TRIM_NONE;
+}
+#endif
+
 bool TrimString(const std::string& input,
                 const char trim_chars[],
                 std::string* output) {
   return TrimStringT(input, trim_chars, TRIM_ALL, output) != TRIM_NONE;
 }
 
 TrimPositions TrimWhitespace(const std::wstring& input,
                              TrimPositions positions,
                              std::wstring* output) {
   return TrimStringT(input, kWhitespaceWide, positions, output);
 }
 
+#if !defined(WCHAR_T_IS_UTF16)
+TrimPositions TrimWhitespace(const string16& input,
+                             TrimPositions positions,
+                             string16* output) {
+  return TrimStringT(input, kWhitespaceUTF16, positions, output);
+}
+#endif
+
 TrimPositions TrimWhitespaceASCII(const std::string& input,
                                   TrimPositions positions,
                                   std::string* output) {
   return TrimStringT(input, kWhitespaceASCII, positions, output);
 }
 
 // This function is only for backward-compatibility.
 // To be removed when all callers are updated.
 TrimPositions TrimWhitespace(const std::string& input,
                              TrimPositions positions,
@@ skipping 41 matching lines @@
 
   result.resize(chars_written);
   return result;
 }
 
 std::wstring CollapseWhitespace(const std::wstring& text,
                                 bool trim_sequences_with_line_breaks) {
   return CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
 }
 
+#if !defined(WCHAR_T_IS_UTF16)
+string16 CollapseWhitespace(const string16& text,
+                            bool trim_sequences_with_line_breaks) {
+  return CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
+}
+#endif
+
 std::string CollapseWhitespaceASCII(const std::string& text,
                                     bool trim_sequences_with_line_breaks) {
   return CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
 }
 
 std::string WideToASCII(const std::wstring& wide) {
   DCHECK(IsStringASCII(wide)) << wide;
   return std::string(wide.begin(), wide.end());
 }
 
@@ skipping 1195 matching lines @@
   // Each input byte creates two output hex characters.
   std::string ret(size * 2, '\0');
 
   for (size_t i = 0; i < size; ++i) {
     char b = reinterpret_cast<const char*>(bytes)[i];
     ret[(i * 2)] = kHexChars[(b >> 4) & 0xf];
     ret[(i * 2) + 1] = kHexChars[b & 0xf];
   }
   return ret;
 }