Port DictionaryValue to use string16 instead of wstring.

base/string_util.h

 // 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.
 //
 // This file defines utility functions for working with strings.
 
 #ifndef BASE_STRING_UTIL_H_
 #define BASE_STRING_UTIL_H_
 
 #include <stdarg.h>   // va_list
@@ skipping 171 matching lines @@
 bool UTF8ToUTF16(const char* src, size_t src_len, string16* output);
 string16 UTF8ToUTF16(const std::string& utf8);
 bool UTF16ToUTF8(const char16* src, size_t src_len, std::string* output);
 std::string UTF16ToUTF8(const string16& utf16);
 
 // We are trying to get rid of wstring as much as possible, but it's too big
 // a mess to do it all at once.  These conversions should be used when we
 // really should just be passing a string16 around, but we haven't finished
 // porting whatever module uses wstring and the conversion is being used as a
 // stopcock.  This makes it easy to grep for the ones that should be removed.
-#if defined(OS_WIN)
+#if defined(WCHAR_T_IS_UTF16)
 # define WideToUTF16Hack
 # define UTF16ToWideHack
 #else
 # define WideToUTF16Hack WideToUTF16
 # define UTF16ToWideHack UTF16ToWide
 #endif
 
 // Defines the error handling modes of WideToCodepage and CodepageToWide.
 class OnStringUtilConversionError {
  public:
@@ skipping 175 matching lines @@
                                   string16::size_type start_offset,
                                   const string16& find_this,
                                   const string16& replace_with);
 void ReplaceSubstringsAfterOffset(std::string* str,
                                   std::string::size_type start_offset,
                                   const std::string& find_this,
                                   const std::string& replace_with);
 
 // Specialized string-conversion functions.
 std::string IntToString(int value);
+string16 IntToString16(int value);
 std::wstring IntToWString(int value);
 std::string UintToString(unsigned int value);
+string16 UintToString16(unsigned int value);
 std::wstring UintToWString(unsigned int value);
 std::string Int64ToString(int64 value);
+string16 Int64ToString16(int64 value);
 std::wstring Int64ToWString(int64 value);
 std::string Uint64ToString(uint64 value);
+string16 Uint64ToString16(uint64 value);
 std::wstring Uint64ToWString(uint64 value);
 // The DoubleToString methods convert the double to a string format that
 // ignores the locale.  If you want to use locale specific formatting, use ICU.
 std::string DoubleToString(double value);
+string16 DoubleToString16(double value);
 std::wstring DoubleToWString(double value);
 
 // Perform a best-effort conversion of the input string to a numeric type,
 // setting |*output| to the result of the conversion.  Returns true for
 // "perfect" conversions; returns false in the following cases:
 //  - Overflow/underflow.  |*output| will be set to the maximum value supported
 //    by the data type.
 //  - Trailing characters in the string after parsing the number.  |*output|
 //    will be set to the value of the number that was parsed.
 //  - No characters parseable as a number at the beginning of the string.
@@ skipping 182 matching lines @@
 // Returns a hex string representation of a binary buffer.
 // The returned hex string will be in upper case.
 // This function does not check if |size| is within reasonable limits since
 // it's written with trusted data in mind.
 // If you suspect that the data you want to format might be large,
 // the absolute max size for |size| should be is
 //   std::numeric_limits<size_t>::max() / 2
 std::string HexEncode(const void* bytes, size_t size);
 
 #endif  // BASE_STRING_UTIL_H_